From 55a63515283eda5c48400b8685d13fa0f6e65b60 Mon Sep 17 00:00:00 2001
From: Lenz Weber-Tronic <lorenz.weber-tronic@apollographql.com>
Date: Thu, 14 Sep 2023 11:29:15 +0200
Subject: [PATCH 1/5] add api extractor

---
 api-extractor.json       | 127 +++++++++
 config/apiExtractor.ts   |  55 ++++
 package-lock.json        | 574 +++++++++++++++++++++++++++++++++++++++
 package.json             |   2 +
 src/core/QueryManager.ts |   2 +-
 5 files changed, 759 insertions(+), 1 deletion(-)
 create mode 100644 api-extractor.json
 create mode 100644 config/apiExtractor.ts

diff --git a/api-extractor.json b/api-extractor.json
new file mode 100644
index 00000000000..f49419996e2
--- /dev/null
+++ b/api-extractor.json
@@ -0,0 +1,127 @@
+/**
+ * Config file for API Extractor.  For more info, please visit: https://api-extractor.com
+ */
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+  "projectFolder": ".",
+  "mainEntryPointFilePath": "<projectFolder>/dist/index.d.ts",
+  "bundledPackages": [],
+  "newlineKind": "lf",
+
+  /**
+   * Set to true when invoking API Extractor's test harness. When `testMode` is true, the `toolVersion` field in the
+   * .api.json file is assigned an empty string to prevent spurious diffs in output files tracked for tests.
+   *
+   * DEFAULT VALUE: "false"
+   */
+  // "testMode": false,
+
+  /**
+   * Determines how the TypeScript compiler engine will be invoked by API Extractor.
+   */
+  "compiler": {
+    "tsconfigFilePath": "<projectFolder>/tsconfig.json",
+    "overrideTsconfig": {},
+    "skipLibCheck": true
+  },
+
+  /**
+   * Configures how the API report file (*.api.md) will be generated.
+   */
+  "apiReport": {
+    "enabled": true,
+    "reportFileName": "<unscopedPackageName>.api.md",
+    "reportFolder": "<projectFolder>/.api-reports/",
+    "reportTempFolder": "<projectFolder>/.api-reports/temp/",
+    "includeForgottenExports": true
+  },
+
+  "docModel": {
+    "enabled": false
+  },
+
+  "dtsRollup": {
+    "enabled": false
+
+  },
+  "tsdocMetadata": {
+    "enabled": false
+  },
+
+  /**
+   * Configures how API Extractor reports error and warning messages produced during analysis.
+   *
+   * There are three sources of messages:  compiler messages, API Extractor messages, and TSDoc messages.
+   */
+  "messages": {
+    /**
+     * Configures handling of diagnostic messages reported by the TypeScript compiler engine while analyzing
+     * the input .d.ts files.
+     *
+     * TypeScript message identifiers start with "TS" followed by an integer.  For example: "TS2551"
+     *
+     * DEFAULT VALUE:  A single "default" entry with logLevel=warning.
+     */
+    "compilerMessageReporting": {
+      /**
+       * Configures the default routing for messages that don't match an explicit rule in this table.
+       */
+      "default": {
+        /**
+         * Specifies whether the message should be written to the the tool's output log.  Note that
+         * the "addToApiReportFile" property may supersede this option.
+         *
+         * Possible values: "error", "warning", "none"
+         *
+         * Errors cause the build to fail and return a nonzero exit code.  Warnings cause a production build fail
+         * and return a nonzero exit code.  For a non-production build (e.g. when "api-extractor run" includes
+         * the "--local" option), the warning is displayed but the build will not fail.
+         *
+         * DEFAULT VALUE: "warning"
+         */
+        "logLevel": "warning"
+
+        /**
+         * When addToApiReportFile is true:  If API Extractor is configured to write an API report file (.api.md),
+         * then the message will be written inside that file; otherwise, the message is instead logged according to
+         * the "logLevel" option.
+         *
+         * DEFAULT VALUE: false
+         */
+        // "addToApiReportFile": false
+      }
+
+      // "TS2551": {
+      //   "logLevel": "warning",
+      //   "addToApiReportFile": true
+      // },
+      //
+      // . . .
+    },
+
+    /**
+     * Configures handling of messages reported by API Extractor during its analysis.
+     *
+     * API Extractor message identifiers start with "ae-".  For example: "ae-extra-release-tag"
+     *
+     * DEFAULT VALUE: See api-extractor-defaults.json for the complete table of extractorMessageReporting mappings
+     */
+    "extractorMessageReporting": {
+      "default": {
+        "logLevel": "warning"
+        // "addToApiReportFile": false
+      },
+
+      "ae-missing-release-tag": {
+        "logLevel": "none"
+      }
+    }
+
+      // "ae-extra-release-tag": {
+      //   "logLevel": "warning",
+      //   "addToApiReportFile": true
+      // },
+      //
+      // . . .
+    }
+}
diff --git a/config/apiExtractor.ts b/config/apiExtractor.ts
new file mode 100644
index 00000000000..c8d6dd86ec0
--- /dev/null
+++ b/config/apiExtractor.ts
@@ -0,0 +1,55 @@
+import * as path from "path";
+import {
+  Extractor,
+  ExtractorConfig,
+  ExtractorResult,
+} from "@microsoft/api-extractor";
+// @ts-ignore
+import { map } from "./entryPoints.js";
+
+// Load and parse the api-extractor.json file
+const configObjectFullPath = path.resolve(__dirname, "../api-extractor.json");
+const baseConfig = ExtractorConfig.loadFile(configObjectFullPath);
+const packageJsonFullPath = path.resolve(__dirname, "../package.json");
+
+process.exitCode = 0;
+
+map((entryPoint: { dirs: string[] }) => {
+  const path = entryPoint.dirs.join("/");
+  const mainEntryPointFilePath =
+    `<projectFolder>/dist/${path}/index.d.ts`.replace("//", "/");
+  console.log(
+    "\n\nCreating API extractor report for " + mainEntryPointFilePath
+  );
+
+  const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
+    configObject: {
+      ...baseConfig,
+      mainEntryPointFilePath,
+      apiReport: {
+        enabled: true,
+        ...baseConfig.apiReport,
+        reportFileName: `api-report${
+          path ? "-" + path.replace("/", "_") : ""
+        }.md`,
+      },
+    },
+    packageJsonFullPath,
+    configObjectFullPath,
+  });
+
+  const extractorResult: ExtractorResult = Extractor.invoke(extractorConfig, {
+    localBuild: process.env.CI === undefined,
+    showVerboseMessages: true,
+  });
+
+  if (extractorResult.succeeded) {
+    console.log(`✅ API Extractor completed successfully`);
+  } else {
+    console.error(
+      `❗ API Extractor completed with ${extractorResult.errorCount} errors` +
+        ` and ${extractorResult.warningCount} warnings`
+    );
+    process.exitCode = 1;
+  }
+});
diff --git a/package-lock.json b/package-lock.json
index 0fc0e9ff5c7..34f91312874 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -30,6 +30,7 @@
         "@changesets/changelog-github": "0.4.8",
         "@changesets/cli": "2.26.2",
         "@graphql-tools/schema": "10.0.0",
+        "@microsoft/api-extractor": "7.36.4",
         "@rollup/plugin-node-resolve": "11.2.1",
         "@size-limit/esbuild-why": "8.2.6",
         "@size-limit/preset-small-lib": "8.2.6",
@@ -1268,6 +1269,38 @@
         "node": ">=12"
       }
     },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.7.tgz",
+      "integrity": "sha512-o0VVztxJPkfDYbaU1tA1G1iwKiBh6Zt3bX5OdHDoITMFdRg+Mgdt3nHXMEtNlIjYA/Xn6hmlOYDHjJfQUduPuw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.7.tgz",
+      "integrity": "sha512-ga8Dtpb01GorCi1dk3jEwDk3AK/3F+cR5P+//Tl0ERL2K2pK/J1f3t8hcJ+RRt3UYBV/uTL9GEnx7touX0KRPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@esbuild/darwin-arm64": {
       "version": "0.18.7",
       "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.7.tgz",
@@ -1284,6 +1317,278 @@
         "node": ">=12"
       }
     },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.7.tgz",
+      "integrity": "sha512-w7aeD1UjDFXqyrZQLBIPYGmLR+gJsl+7QSwmSz+nVrCZOB7cyWEkIjCF8s4inUD3ja3WtKUIqzX5S4qDnU5q7Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.7.tgz",
+      "integrity": "sha512-wKyySDdoKVOPn9eDci/b3eP3EJVAVXC3b2CiaHphhCKfh4n5pWLwj7Ue96anK1HnpcZ0Uti8Sw9xq3Im0earHA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.7.tgz",
+      "integrity": "sha512-rbfjbgSvzWRjQMKIntogK1d2oIAiA/ZVayXfK1WjcIIMQYLg74sAoT8CZBj30+bwn13YR0t6lgIxA1mJaS2Lhw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.7.tgz",
+      "integrity": "sha512-GpUBqqJnQ+7qdb7NqKNVj7TgD2JnLrEdzPtatPow77Me/EQ01GE1tHKZLePqhf5thdLDb5Se2Kcf4D9WTbSjmw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.7.tgz",
+      "integrity": "sha512-cwfxKYroaD5BZ42NsfxdVU1issD2NxcuJHlCNsN5LtWq+kZMpwmIVDCJxKlgLIG7zH/4yq8lTuZJurxq058GsA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.7.tgz",
+      "integrity": "sha512-SsvsGStwbArBcB/XNh+2MvUtgOLp0CR6Hn1PBWcdApCuAaMibHCDyzHS06+u/YOD1UpeXFHJZphix61HeVMH/w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.7.tgz",
+      "integrity": "sha512-/dKQ3OLr2Tmj0kuf4ZJioD+qnADUEJSBaiuDbk8v5602HnNNBSGHPrEB6S8PSb8y8jWsX9MMnxqk5KpLTf86OQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.7.tgz",
+      "integrity": "sha512-x/k1+daIqiGJt0Yhr5llFJ/zkRg1XAqcS2ntAYzS3pHogO8oIyc+LjsINgVyFCeFMFUZ9Ae9W5z2Ib05bMum3g==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.7.tgz",
+      "integrity": "sha512-LegTDzK9gL/sTkiZUGYLigTISwppZJvQL3MRmFgXgHrj3IzdWkPgMwEtOItK3YiFzhBSSNyKA0mSKEg4UuK8JQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.7.tgz",
+      "integrity": "sha512-fjBl45O8ivc3Nl14hdGpbHoVtdHnYGsLpwnlv2rNyb5NOsgY3Y8EhVe/fqR9ndHgO4eL68knKxkrRveEJq+v1g==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.7.tgz",
+      "integrity": "sha512-apYLJsg3wd3hW8nEt7H++8c8rTDvwXxX7h7YeI89g1RDPCT2QSXTO/xT1BCvFa/BFFoau+yvepQg2o5556FIWQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.7.tgz",
+      "integrity": "sha512-f82sUnrzdoW4MiiCDn1G3RSsPH8+no+okDhkHgGTGa+5F5wZCyxdXxzR6ctsiimvyPn9FIu9Zs+MesVsBRwyTw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.7.tgz",
+      "integrity": "sha512-1TNDfpFYhIloHeqSRbJFjHFMYtTJWgqI2+S9uCLVCWrADLl5tCe8vQKDfkM7Afz/lZyqi6qEX/Eg2KA5S7FcNQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.7.tgz",
+      "integrity": "sha512-lBhsHaM6EYCmzQCj+xeFev+dgqTgpSRqF7qXrxp5V4waFuidTBbWgqSXY5rsLRNLOyMMCh1cA+RqF8UL30oOJQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.7.tgz",
+      "integrity": "sha512-p9ipv7rPKitXAAeufg5BzmyYZHZtFfrLGUX15+AxpTQqSZDAZd2wIusaOW5oONTf8RB53ujIqQw7W0QnZMuiUw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.7.tgz",
+      "integrity": "sha512-WmNxuE+j1wUT2rK+e1Oakx3zobS1rPpQudPytGM4nxXEGv0gpXEvnZnrykRwriNFbGVCwFJoE4txayjW76LsCw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.7.tgz",
+      "integrity": "sha512-6RENfAwwL6dxQk/V1PxO/ejYRiOUVUaHi99hP3Dso/38jfNKFzU6YSSR/haJGNV/2wAHIgBMROQodna0IejAuA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.2.0.tgz",
@@ -2087,6 +2392,99 @@
         "node": ">=6 <7 || >=8"
       }
     },
+    "node_modules/@microsoft/api-extractor": {
+      "version": "7.36.4",
+      "resolved": "https://registry.npmjs.org/@microsoft/api-extractor/-/api-extractor-7.36.4.tgz",
+      "integrity": "sha512-21UECq8C/8CpHT23yiqTBQ10egKUacIpxkPyYR7hdswo/M5yTWdBvbq+77YC9uPKQJOUfOD1FImBQ1DzpsdeQQ==",
+      "dev": true,
+      "dependencies": {
+        "@microsoft/api-extractor-model": "7.27.6",
+        "@microsoft/tsdoc": "0.14.2",
+        "@microsoft/tsdoc-config": "~0.16.1",
+        "@rushstack/node-core-library": "3.59.7",
+        "@rushstack/rig-package": "0.4.1",
+        "@rushstack/ts-command-line": "4.15.2",
+        "colors": "~1.2.1",
+        "lodash": "~4.17.15",
+        "resolve": "~1.22.1",
+        "semver": "~7.5.4",
+        "source-map": "~0.6.1",
+        "typescript": "~5.0.4"
+      },
+      "bin": {
+        "api-extractor": "bin/api-extractor"
+      }
+    },
+    "node_modules/@microsoft/api-extractor-model": {
+      "version": "7.27.6",
+      "resolved": "https://registry.npmjs.org/@microsoft/api-extractor-model/-/api-extractor-model-7.27.6.tgz",
+      "integrity": "sha512-eiCnlayyum1f7fS2nA9pfIod5VCNR1G+Tq84V/ijDrKrOFVa598BLw145nCsGDMoFenV6ajNi2PR5WCwpAxW6Q==",
+      "dev": true,
+      "dependencies": {
+        "@microsoft/tsdoc": "0.14.2",
+        "@microsoft/tsdoc-config": "~0.16.1",
+        "@rushstack/node-core-library": "3.59.7"
+      }
+    },
+    "node_modules/@microsoft/api-extractor/node_modules/semver": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+      "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==",
+      "dev": true,
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@microsoft/api-extractor/node_modules/typescript": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz",
+      "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=12.20"
+      }
+    },
+    "node_modules/@microsoft/tsdoc": {
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz",
+      "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==",
+      "dev": true
+    },
+    "node_modules/@microsoft/tsdoc-config": {
+      "version": "0.16.2",
+      "resolved": "https://registry.npmjs.org/@microsoft/tsdoc-config/-/tsdoc-config-0.16.2.tgz",
+      "integrity": "sha512-OGiIzzoBLgWWR0UdRJX98oYO+XKGf7tiK4Zk6tQ/E4IJqGCe7dvkTvgDZV5cFJUzLGDOjeAXrnZoA6QkVySuxw==",
+      "dev": true,
+      "dependencies": {
+        "@microsoft/tsdoc": "0.14.2",
+        "ajv": "~6.12.6",
+        "jju": "~1.4.0",
+        "resolve": "~1.19.0"
+      }
+    },
+    "node_modules/@microsoft/tsdoc-config/node_modules/resolve": {
+      "version": "1.19.0",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz",
+      "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==",
+      "dev": true,
+      "dependencies": {
+        "is-core-module": "^2.1.0",
+        "path-parse": "^1.0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -2175,6 +2573,66 @@
       "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
       "dev": true
     },
+    "node_modules/@rushstack/node-core-library": {
+      "version": "3.59.7",
+      "resolved": "https://registry.npmjs.org/@rushstack/node-core-library/-/node-core-library-3.59.7.tgz",
+      "integrity": "sha512-ln1Drq0h+Hwa1JVA65x5mlSgUrBa1uHL+V89FqVWQgXd1vVIMhrtqtWGQrhTnFHxru5ppX+FY39VWELF/FjQCw==",
+      "dev": true,
+      "dependencies": {
+        "colors": "~1.2.1",
+        "fs-extra": "~7.0.1",
+        "import-lazy": "~4.0.0",
+        "jju": "~1.4.0",
+        "resolve": "~1.22.1",
+        "semver": "~7.5.4",
+        "z-schema": "~5.0.2"
+      },
+      "peerDependencies": {
+        "@types/node": "*"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rushstack/node-core-library/node_modules/semver": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+      "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==",
+      "dev": true,
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@rushstack/rig-package": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@rushstack/rig-package/-/rig-package-0.4.1.tgz",
+      "integrity": "sha512-AGRwpqlXNSp9LhUSz4HKI9xCluqQDt/obsQFdv/NYIekF3pTTPzc+HbQsIsjVjYnJ3DcmxOREVMhvrMEjpiq6g==",
+      "dev": true,
+      "dependencies": {
+        "resolve": "~1.22.1",
+        "strip-json-comments": "~3.1.1"
+      }
+    },
+    "node_modules/@rushstack/ts-command-line": {
+      "version": "4.15.2",
+      "resolved": "https://registry.npmjs.org/@rushstack/ts-command-line/-/ts-command-line-4.15.2.tgz",
+      "integrity": "sha512-5+C2uoJY8b+odcZD6coEe2XNC4ZjGB4vCMESbqW/8DHRWC/qIHfANdmN9F1wz/lAgxz72i7xRoVtPY2j7e4gpQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/argparse": "1.0.38",
+        "argparse": "~1.0.9",
+        "colors": "~1.2.1",
+        "string-argv": "~0.3.1"
+      }
+    },
     "node_modules/@sinclair/typebox": {
       "version": "0.27.8",
       "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
@@ -2507,6 +2965,12 @@
       "integrity": "sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==",
       "dev": true
     },
+    "node_modules/@types/argparse": {
+      "version": "1.0.38",
+      "resolved": "https://registry.npmjs.org/@types/argparse/-/argparse-1.0.38.tgz",
+      "integrity": "sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA==",
+      "dev": true
+    },
     "node_modules/@types/aria-query": {
       "version": "4.2.2",
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-4.2.2.tgz",
@@ -3992,6 +4456,15 @@
       "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
       "dev": true
     },
+    "node_modules/colors": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/colors/-/colors-1.2.5.tgz",
+      "integrity": "sha512-erNRLao/Y3Fv54qUa0LBB+//Uf3YwMUmdJinN20yMXm9zdKKqH9wt7R9IIVZ+K7ShzfpLV/Zg8+VyrBJYB4lpg==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.1.90"
+      }
+    },
     "node_modules/combined-stream": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
@@ -4638,6 +5111,38 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/esbuild/node_modules/@esbuild/android-arm": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.7.tgz",
+      "integrity": "sha512-nDQ7AC5WVKOqxaip/E5YbaRgnilBMsoGKjoGLCeCOYNePaBCBDwJsLfa2fn3FEtktiLaAF990W592avsHjJ/Vg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild/node_modules/@esbuild/linux-loong64": {
+      "version": "0.18.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.7.tgz",
+      "integrity": "sha512-WOqQ0eaWGE/e9vmbxFT2exbWuXxHuG8ld0fN7oX5f0v7W6oveUIF4DLJYVae93t1+Icv5R0NBo8wv/o4hEvxBQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/escalade": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
@@ -6013,6 +6518,15 @@
         "node": ">=4"
       }
     },
+    "node_modules/import-lazy": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-4.0.0.tgz",
+      "integrity": "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/import-local": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz",
@@ -7591,6 +8105,12 @@
         "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
+    "node_modules/jju": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/jju/-/jju-1.4.0.tgz",
+      "integrity": "sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==",
+      "dev": true
+    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -7873,6 +8393,12 @@
       "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
       "dev": true
     },
+    "node_modules/lodash.get": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
+      "integrity": "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==",
+      "dev": true
+    },
     "node_modules/lodash.isequal": {
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
@@ -10072,6 +10598,15 @@
         "mixme": "^0.5.1"
       }
     },
+    "node_modules/string-argv": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/string-argv/-/string-argv-0.3.2.tgz",
+      "integrity": "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.6.19"
+      }
+    },
     "node_modules/string-length": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz",
@@ -10872,6 +11407,15 @@
         "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
       }
     },
+    "node_modules/validator": {
+      "version": "13.11.0",
+      "resolved": "https://registry.npmjs.org/validator/-/validator-13.11.0.tgz",
+      "integrity": "sha512-Ii+sehpSfZy+At5nPdnyMhx78fEoPDkR2XW/zimHEL3MyGJQOCQ7WeP20jPYRz7ZCpcKLB21NxuXHF3bxjStBQ==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/value-or-promise": {
       "version": "1.0.12",
       "resolved": "https://registry.npmjs.org/value-or-promise/-/value-or-promise-1.0.12.tgz",
@@ -11313,6 +11857,36 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/z-schema": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/z-schema/-/z-schema-5.0.5.tgz",
+      "integrity": "sha512-D7eujBWkLa3p2sIpJA0d1pr7es+a7m0vFAnZLlCEKq/Ij2k0MLi9Br2UPxoxdYystm5K1yeBGzub0FlYUEWj2Q==",
+      "dev": true,
+      "dependencies": {
+        "lodash.get": "^4.4.2",
+        "lodash.isequal": "^4.5.0",
+        "validator": "^13.7.0"
+      },
+      "bin": {
+        "z-schema": "bin/z-schema"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "commander": "^9.4.1"
+      }
+    },
+    "node_modules/z-schema/node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "dev": true,
+      "optional": true,
+      "engines": {
+        "node": "^12.20.0 || >=14"
+      }
+    },
     "node_modules/zen-observable": {
       "version": "0.8.15",
       "resolved": "https://registry.npmjs.org/zen-observable/-/zen-observable-0.8.15.tgz",
diff --git a/package.json b/package.json
index 075d2e16762..9ae1d809773 100644
--- a/package.json
+++ b/package.json
@@ -42,6 +42,7 @@
     "prepdist": "node ./config/prepareDist.js",
     "prepdist:changesets": "ts-node-script config/prepareChangesetsRelease.ts",
     "postprocess-dist": "ts-node-script config/postprocessDist.ts",
+    "extract-api": "ts-node-script config/apiExtractor.ts",
     "clean": "rimraf dist coverage lib temp",
     "check:format": "prettier --check .",
     "ci:precheck": "node config/precheck.js",
@@ -107,6 +108,7 @@
     "@changesets/changelog-github": "0.4.8",
     "@changesets/cli": "2.26.2",
     "@graphql-tools/schema": "10.0.0",
+    "@microsoft/api-extractor": "7.36.4",
     "@rollup/plugin-node-resolve": "11.2.1",
     "@size-limit/esbuild-why": "8.2.6",
     "@size-limit/preset-small-lib": "8.2.6",
diff --git a/src/core/QueryManager.ts b/src/core/QueryManager.ts
index efdd3c05a92..201968db79b 100644
--- a/src/core/QueryManager.ts
+++ b/src/core/QueryManager.ts
@@ -96,7 +96,7 @@ interface TransformCacheEntry {
   asQuery: DocumentNode;
 }
 
-type DefaultOptions = import("./ApolloClient.js").DefaultOptions;
+import type { DefaultOptions } from "./ApolloClient.js";
 
 export class QueryManager<TStore> {
   public cache: ApolloCache<TStore>;

From f9099218f7569e3560cf3fd3538f2eab9db66637 Mon Sep 17 00:00:00 2001
From: Lenz Weber-Tronic <lorenz.weber-tronic@apollographql.com>
Date: Thu, 14 Sep 2023 11:29:21 +0200
Subject: [PATCH 2/5] add api reports

---
 .api-reports/api-report-cache.md              |  958 ++++++
 .api-reports/api-report-core.md               | 2196 +++++++++++++
 .api-reports/api-report-dev.md                |   30 +
 .api-reports/api-report-errors.md             |  174 +
 .api-reports/api-report-link_batch-http.md    |  258 ++
 .api-reports/api-report-link_batch.md         |  216 ++
 .api-reports/api-report-link_context.md       |  172 +
 .api-reports/api-report-link_core.md          |  170 +
 .api-reports/api-report-link_error.md         |  232 ++
 .api-reports/api-report-link_http.md          |  335 ++
 .../api-report-link_persisted-queries.md      |  259 ++
 .../api-report-link_remove-typename.md        |  186 ++
 .api-reports/api-report-link_retry.md         |  220 ++
 .api-reports/api-report-link_schema.md        |  201 ++
 .api-reports/api-report-link_subscriptions.md |  176 +
 .api-reports/api-report-link_utils.md         |   84 +
 .api-reports/api-report-link_ws.md            |  198 ++
 .api-reports/api-report-react.md              | 2237 +++++++++++++
 .api-reports/api-report-react_components.md   | 1748 ++++++++++
 .api-reports/api-report-react_context.md      | 1646 ++++++++++
 .api-reports/api-report-react_hoc.md          | 1690 ++++++++++
 .api-reports/api-report-react_hooks.md        | 2130 ++++++++++++
 .api-reports/api-report-react_parser.md       |   42 +
 .api-reports/api-report-react_ssr.md          | 1633 ++++++++++
 .api-reports/api-report-testing.md            | 1681 ++++++++++
 .api-reports/api-report-testing_core.md       | 1639 ++++++++++
 .api-reports/api-report-utilities.md          | 2526 ++++++++++++++
 .api-reports/api-report-utilities_globals.md  |   51 +
 .api-reports/api-report.md                    | 2902 +++++++++++++++++
 29 files changed, 25990 insertions(+)
 create mode 100644 .api-reports/api-report-cache.md
 create mode 100644 .api-reports/api-report-core.md
 create mode 100644 .api-reports/api-report-dev.md
 create mode 100644 .api-reports/api-report-errors.md
 create mode 100644 .api-reports/api-report-link_batch-http.md
 create mode 100644 .api-reports/api-report-link_batch.md
 create mode 100644 .api-reports/api-report-link_context.md
 create mode 100644 .api-reports/api-report-link_core.md
 create mode 100644 .api-reports/api-report-link_error.md
 create mode 100644 .api-reports/api-report-link_http.md
 create mode 100644 .api-reports/api-report-link_persisted-queries.md
 create mode 100644 .api-reports/api-report-link_remove-typename.md
 create mode 100644 .api-reports/api-report-link_retry.md
 create mode 100644 .api-reports/api-report-link_schema.md
 create mode 100644 .api-reports/api-report-link_subscriptions.md
 create mode 100644 .api-reports/api-report-link_utils.md
 create mode 100644 .api-reports/api-report-link_ws.md
 create mode 100644 .api-reports/api-report-react.md
 create mode 100644 .api-reports/api-report-react_components.md
 create mode 100644 .api-reports/api-report-react_context.md
 create mode 100644 .api-reports/api-report-react_hoc.md
 create mode 100644 .api-reports/api-report-react_hooks.md
 create mode 100644 .api-reports/api-report-react_parser.md
 create mode 100644 .api-reports/api-report-react_ssr.md
 create mode 100644 .api-reports/api-report-testing.md
 create mode 100644 .api-reports/api-report-testing_core.md
 create mode 100644 .api-reports/api-report-utilities.md
 create mode 100644 .api-reports/api-report-utilities_globals.md
 create mode 100644 .api-reports/api-report.md

diff --git a/.api-reports/api-report-cache.md b/.api-reports/api-report-cache.md
new file mode 100644
index 00000000000..e2135907143
--- /dev/null
+++ b/.api-reports/api-report-cache.md
@@ -0,0 +1,958 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { InlineFragmentNode } from 'graphql';
+import type { SelectionSetNode } from 'graphql';
+import { Trie } from '@wry/trie';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// @public (undocumented)
+export abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export type ApolloReducerConfig = {
+    dataIdFromObject?: KeyFieldsFunction;
+    addTypename?: boolean;
+};
+
+// @public (undocumented)
+type BroadcastOptions = Pick<Cache_2.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+export { Cache_2 as Cache }
+
+// @public (undocumented)
+class CacheGroup {
+    constructor(caching: boolean, parent?: CacheGroup | null);
+    // (undocumented)
+    readonly caching: boolean;
+    // (undocumented)
+    depend(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    dirty(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    keyMaker: Trie<object>;
+    // (undocumented)
+    resetCaching(): void;
+}
+
+// @public (undocumented)
+export const cacheSlot: {
+    readonly id: string;
+    hasValue(): boolean;
+    getValue(): ApolloCache<any> | undefined;
+    withValue<TResult, TArgs extends any[], TThis = any>(value: ApolloCache<any>, callback: (this: TThis, ...args: TArgs) => TResult, args?: TArgs | undefined, thisArg?: TThis | undefined): TResult;
+};
+
+// @public (undocumented)
+export const canonicalStringify: ((value: any) => string) & {
+    reset: typeof resetCanonicalStringify;
+};
+
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+export function createFragmentRegistry(...fragments: DocumentNode[]): FragmentRegistryAPI;
+
+// @public (undocumented)
+export namespace DataProxy {
+    // (undocumented)
+    export type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    export interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    export interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    export interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // (undocumented)
+    export interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // (undocumented)
+    export interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    export interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    export interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    export interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // (undocumented)
+    export interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+export interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "KeyFieldsContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function defaultDataIdFromObject({ __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext): string | undefined;
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+export type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
+    returnPartialData?: boolean;
+};
+
+// @public (undocumented)
+export abstract class EntityStore implements NormalizedCache {
+    constructor(policies: Policies, group: CacheGroup);
+    // Warning: (ae-forgotten-export) The symbol "Layer" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // Warning: (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    protected data: NormalizedCacheObject;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string, args?: Record<string, any>): boolean;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions, limit: EntityStore): boolean;
+    // (undocumented)
+    extract(): NormalizedCacheObject;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
+    // (undocumented)
+    getRootIdSet(ids?: Set<string>): Set<string>;
+    // Warning: (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // Warning: (ae-forgotten-export) The symbol "CacheGroup" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    protected lookup(dataId: string, dependOnExistence?: boolean): StoreObject | undefined;
+    // (undocumented)
+    makeCacheKey(...args: any[]): object;
+    // (undocumented)
+    merge(older: string | StoreObject, newer: StoreObject | string): void;
+    // (undocumented)
+    modify(dataId: string, fields: Modifier<any> | Modifiers<Record<string, any>>): boolean;
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    abstract removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject | null): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // Warning: (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+export namespace EntityStore {
+    // (undocumented)
+    export class Root extends EntityStore {
+        constructor({ policies, resultCaching, seed, }: {
+            policies: Policies;
+            resultCaching?: boolean;
+            seed?: NormalizedCacheObject;
+        });
+        // (undocumented)
+        addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+        // (undocumented)
+        getStorage(): StorageType;
+        // (undocumented)
+        removeLayer(): Root;
+        // (undocumented)
+        readonly storageTrie: Trie<StorageType>;
+        // Warning: (ae-forgotten-export) The symbol "Stump" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        readonly stump: Stump;
+    }
+}
+
+// @public (undocumented)
+export interface FieldFunctionOptions<TArgs = Record<string, any>, TVars = Record<string, any>> {
+    // (undocumented)
+    args: TArgs | null;
+    // (undocumented)
+    cache: InMemoryCache;
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    field: FieldNode | null;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    isReference: typeof isReference;
+    // Warning: (ae-forgotten-export) The symbol "MergeObjectsFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    mergeObjects: MergeObjectsFunction;
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField: ReadFieldFunction;
+    // (undocumented)
+    storage: StorageType;
+    // (undocumented)
+    storeFieldName: string;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+    // (undocumented)
+    variables?: TVars;
+}
+
+// @public (undocumented)
+export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
+
+// @public (undocumented)
+export function fieldNameFromStoreName(storeFieldName: string): string;
+
+// @public (undocumented)
+export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
+    keyArgs?: KeySpecifier | KeyArgsFunction | false;
+    read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
+    merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
+};
+
+// @public (undocumented)
+export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type FieldValueGetter = EntityStore["getFieldValue"];
+
+// Warning: (ae-forgotten-export) The symbol "WriteContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FlavorableWriteContext = Pick<WriteContext, "clientOnly" | "deferred" | "flavors">;
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMapFunction = (fragmentName: string) => FragmentDefinitionNode | null;
+
+// @public (undocumented)
+export interface FragmentRegistryAPI {
+    // (undocumented)
+    lookup(fragmentName: string): FragmentDefinitionNode | null;
+    // (undocumented)
+    register(...fragments: DocumentNode[]): this;
+    // (undocumented)
+    transform<D extends DocumentNode>(document: D): D;
+}
+
+// @public (undocumented)
+export type IdGetter = (value: IdGetterObj) => string | undefined;
+
+// @public (undocumented)
+export interface IdGetterObj extends Object {
+    // (undocumented)
+    __typename?: string;
+    // (undocumented)
+    id?: string;
+    // (undocumented)
+    _id?: string;
+}
+
+// @public (undocumented)
+export class InMemoryCache extends ApolloCache<NormalizedCacheObject> {
+    constructor(config?: InMemoryCacheConfig);
+    // (undocumented)
+    readonly assumeImmutableResults = true;
+    // (undocumented)
+    batch<TUpdateResult>(options: Cache_2.BatchOptions<InMemoryCache, TUpdateResult>): TUpdateResult;
+    // Warning: (ae-forgotten-export) The symbol "BroadcastOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected broadcastWatches(options?: BroadcastOptions): void;
+    // (undocumented)
+    protected config: InMemoryCacheConfig;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    diff<TData, TVariables extends OperationVariables = any>(options: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    extract(optimistic?: boolean): NormalizedCacheObject;
+    // (undocumented)
+    gc(options?: {
+        resetResultCache?: boolean;
+        resetResultIdentities?: boolean;
+    }): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    readonly makeVar: typeof makeVar;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any;
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    read<T>(options: Cache_2.ReadOptions): T | null;
+    // (undocumented)
+    release(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    removeOptimistic(idToRemove: string): void;
+    // (undocumented)
+    reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    restore(data: NormalizedCacheObject): this;
+    // (undocumented)
+    retain(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    write(options: Cache_2.WriteOptions): Reference | undefined;
+}
+
+// @public (undocumented)
+export interface InMemoryCacheConfig extends ApolloReducerConfig {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    fragments?: FragmentRegistryAPI;
+    // (undocumented)
+    possibleTypes?: PossibleTypesMap;
+    // (undocumented)
+    resultCacheMaxSize?: number;
+    // (undocumented)
+    resultCaching?: boolean;
+    // (undocumented)
+    typePolicies?: TypePolicies;
+}
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+export function isReference(obj: any): obj is Reference;
+
+// @public (undocumented)
+type KeyArgsFunction = (args: Record<string, any> | null, context: {
+    typename: string;
+    fieldName: string;
+    field: FieldNode | null;
+    variables?: Record<string, any>;
+}) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeyFieldsContext = {
+    typename: string | undefined;
+    storeObject: StoreObject;
+    readField: ReadFieldFunction;
+    selectionSet?: SelectionSetNode;
+    fragmentMap?: FragmentMap;
+    keyObject?: Record<string, any>;
+};
+
+// @public (undocumented)
+type KeyFieldsFunction = (object: Readonly<StoreObject>, context: KeyFieldsContext) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeySpecifier = ReadonlyArray<string | KeySpecifier>;
+
+// @public (undocumented)
+class Layer extends EntityStore {
+    constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup);
+    // (undocumented)
+    addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    getStorage(): StorageType;
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly parent: EntityStore;
+    // (undocumented)
+    removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    readonly replay: (layer: EntityStore) => any;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+}
+
+// @public (undocumented)
+export function makeReference(id: string): Reference;
+
+// @public (undocumented)
+export function makeVar<T>(value: T): ReactiveVar<T>;
+
+// @public (undocumented)
+export interface MergeInfo {
+    // (undocumented)
+    field: FieldNode;
+    // (undocumented)
+    merge: FieldMergeFunction;
+    // (undocumented)
+    typename: string | undefined;
+}
+
+// @public (undocumented)
+type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;
+
+// @public (undocumented)
+export interface MergeTree {
+    // (undocumented)
+    info?: MergeInfo;
+    // (undocumented)
+    map: Map<string | number, MergeTree>;
+}
+
+// @public (undocumented)
+export class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+export type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+export type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+export type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+export interface NormalizedCache {
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string): boolean;
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "FieldValueGetter" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: FieldValueGetter;
+    // (undocumented)
+    getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    merge(olderId: string, newerObject: StoreObject): void;
+    // (undocumented)
+    merge(olderObject: StoreObject, newerId: string): void;
+    // (undocumented)
+    modify<Entity extends Record<string, any>>(dataId: string, fields: Modifiers<Entity> | AllFieldsModifier<Entity>): boolean;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+export interface NormalizedCacheObject {
+    // (undocumented)
+    [dataId: string]: StoreObject | undefined;
+    // (undocumented)
+    __META?: {
+        extraRootIds: string[];
+    };
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+export type OptimisticStoreItem = {
+    id: string;
+    data: NormalizedCacheObject;
+    transaction: Transaction<NormalizedCacheObject>;
+};
+
+// @public (undocumented)
+export class Policies {
+    constructor(config: {
+        cache: InMemoryCache;
+        dataIdFromObject?: KeyFieldsFunction;
+        possibleTypes?: PossibleTypesMap;
+        typePolicies?: TypePolicies;
+    });
+    // (undocumented)
+    addPossibleTypes(possibleTypes: PossibleTypesMap): void;
+    // (undocumented)
+    addTypePolicies(typePolicies: TypePolicies): void;
+    // (undocumented)
+    readonly cache: InMemoryCache;
+    // (undocumented)
+    fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string | undefined, result?: Record<string, any>, variables?: Record<string, any>): boolean;
+    // (undocumented)
+    getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
+    // (undocumented)
+    getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
+    // Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getStoreFieldName(fieldSpec: FieldSpecifier): string;
+    // (undocumented)
+    hasKeyArgs(typename: string | undefined, fieldName: string): boolean;
+    // (undocumented)
+    identify(object: StoreObject, partialContext?: Partial<KeyFieldsContext>): [string?, StoreObject?];
+    // (undocumented)
+    readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
+    // (undocumented)
+    readonly rootIdsByTypename: Record<string, string>;
+    // (undocumented)
+    readonly rootTypenamesById: Record<string, string>;
+    // (undocumented)
+    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
+    // (undocumented)
+    readonly usingPossibleTypes = false;
+}
+
+// @public (undocumented)
+export type PossibleTypesMap = {
+    [supertype: string]: string[];
+};
+
+// @public (undocumented)
+type ReactiveListener<T> = (value: T) => any;
+
+// @public (undocumented)
+export interface ReactiveVar<T> {
+    // (undocumented)
+    (newValue?: T): T;
+    // (undocumented)
+    attachCache(cache: ApolloCache<any>): this;
+    // (undocumented)
+    forgetCache(cache: ApolloCache<any>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onNextChange(listener: ReactiveListener<T>): () => void;
+}
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// @public (undocumented)
+export interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+export interface ReadMergeModifyContext {
+    // (undocumented)
+    store: NormalizedCache;
+    // (undocumented)
+    variables?: Record<string, any>;
+    // (undocumented)
+    varString?: string;
+}
+
+// @public (undocumented)
+export type ReadQueryOptions = {
+    store: NormalizedCache;
+    query: DocumentNode;
+    variables?: Object;
+    previousResult?: any;
+    canonizeResults?: boolean;
+    rootId?: string;
+    config?: ApolloReducerConfig;
+};
+
+// @public (undocumented)
+export interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+function resetCanonicalStringify(): void;
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+export interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+export type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+class Stump extends Layer {
+    constructor(root: EntityStore.Root);
+    // (undocumented)
+    merge(): any;
+    // (undocumented)
+    removeLayer(): this;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+export type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+export type TypePolicies = {
+    [__typename: string]: TypePolicy;
+};
+
+// @public (undocumented)
+export type TypePolicy = {
+    keyFields?: KeySpecifier | KeyFieldsFunction | false;
+    merge?: FieldMergeFunction | boolean;
+    queryType?: true;
+    mutationType?: true;
+    subscriptionType?: true;
+    fields?: {
+        [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
+    };
+};
+
+// @public (undocumented)
+interface WriteContext extends ReadMergeModifyContext {
+    // (undocumented)
+    clientOnly: boolean;
+    // (undocumented)
+    deferred: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FlavorableWriteContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    flavors: Map<string, FlavorableWriteContext>;
+    // (undocumented)
+    readonly fragmentMap: FragmentMap;
+    // (undocumented)
+    incomingById: Map<string, {
+        storeObject: StoreObject;
+        mergeTree?: MergeTree;
+        fieldNodeSet: Set<FieldNode>;
+    }>;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMapFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    lookupFragment: FragmentMapFunction;
+    // (undocumented)
+    merge<T>(existing: T, incoming: T): T;
+    // (undocumented)
+    overwrite: boolean;
+    // (undocumented)
+    readonly written: {
+        [dataId: string]: SelectionSetNode[];
+    };
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/inmemory/object-canon.ts:203:32 - (ae-forgotten-export) The symbol "resetCanonicalStringify" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:98:3 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeySpecifier" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeyArgsFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/types.ts:126:3 - (ae-forgotten-export) The symbol "KeyFieldsFunction" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-core.md b/.api-reports/api-report-core.md
new file mode 100644
index 00000000000..0bc6fab994b
--- /dev/null
+++ b/.api-reports/api-report-core.md
@@ -0,0 +1,2196 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ASTNode } from 'graphql';
+import { disableExperimentalFragmentVariables } from 'graphql-tag';
+import { disableFragmentWarnings } from 'graphql-tag';
+import type { DocumentNode } from 'graphql';
+import { enableExperimentalFragmentVariables } from 'graphql-tag';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import { gql } from 'graphql-tag';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import type { InlineFragmentNode } from 'graphql';
+import { InvariantError } from 'ts-invariant';
+import { Observable } from 'zen-observable-ts';
+import type { Subscription as ObservableSubscription } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import { print as print_3 } from 'graphql';
+import { resetCaches } from 'graphql-tag';
+import type { SelectionSetNode } from 'graphql';
+import { setVerbosity as setLogVerbosity } from 'ts-invariant';
+import type { Subscriber } from 'zen-observable-ts';
+import { Trie } from '@wry/trie';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// @public (undocumented)
+export abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+export class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+export class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+export interface ApolloPayloadResult<TData = Record<string, any>, TExtensions = Record<string, any>> {
+    // (undocumented)
+    errors?: ReadonlyArray<Error | string>;
+    // (undocumented)
+    payload: SingleExecutionResult | ExecutionPatchResult | null;
+}
+
+// @public (undocumented)
+export type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+export type ApolloReducerConfig = {
+    dataIdFromObject?: KeyFieldsFunction;
+    addTypename?: boolean;
+};
+
+// @public (undocumented)
+interface Body_2 {
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type BroadcastOptions = Pick<Cache_2.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+export { Cache_2 as Cache }
+
+// @public (undocumented)
+class CacheGroup {
+    constructor(caching: boolean, parent?: CacheGroup | null);
+    // (undocumented)
+    readonly caching: boolean;
+    // (undocumented)
+    depend(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    dirty(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    keyMaker: Trie<object>;
+    // (undocumented)
+    resetCaching(): void;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+export const checkFetcher: (fetcher: WindowOrWorkerGlobalScope["fetch"] | undefined) => void;
+
+// @public (undocumented)
+export type ClientParseError = InvariantError & {
+    parseError: Error;
+};
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+export const concat: typeof ApolloLink.concat;
+
+// @public (undocumented)
+export const createHttpLink: (linkOptions?: HttpOptions) => ApolloLink;
+
+// @public (undocumented)
+export const createSignalIfSupported: () => {
+    controller: boolean;
+    signal: boolean;
+} | {
+    controller: AbortController;
+    signal: AbortSignal;
+};
+
+// @public (undocumented)
+export namespace DataProxy {
+    // (undocumented)
+    export type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    export interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    export interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    export interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // (undocumented)
+    export interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // (undocumented)
+    export interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    export interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    export interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    export interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // (undocumented)
+    export interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+export interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "KeyFieldsContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function defaultDataIdFromObject({ __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext): string | undefined;
+
+// @public (undocumented)
+export interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Printer" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const defaultPrinter: Printer;
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+export type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
+    returnPartialData?: boolean;
+};
+
+export { disableExperimentalFragmentVariables }
+
+export { disableFragmentWarnings }
+
+export { DocumentNode }
+
+// @public (undocumented)
+export class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+export type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+export const empty: typeof ApolloLink.empty;
+
+export { enableExperimentalFragmentVariables }
+
+// @public (undocumented)
+abstract class EntityStore implements NormalizedCache {
+    constructor(policies: Policies, group: CacheGroup);
+    // Warning: (ae-forgotten-export) The symbol "Layer" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // Warning: (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    protected data: NormalizedCacheObject;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string, args?: Record<string, any>): boolean;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions, limit: EntityStore): boolean;
+    // (undocumented)
+    extract(): NormalizedCacheObject;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
+    // (undocumented)
+    getRootIdSet(ids?: Set<string>): Set<string>;
+    // Warning: (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // Warning: (ae-forgotten-export) The symbol "CacheGroup" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    protected lookup(dataId: string, dependOnExistence?: boolean): StoreObject | undefined;
+    // (undocumented)
+    makeCacheKey(...args: any[]): object;
+    // (undocumented)
+    merge(older: string | StoreObject, newer: StoreObject | string): void;
+    // (undocumented)
+    modify(dataId: string, fields: Modifier<any> | Modifiers<Record<string, any>>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Policies" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    abstract removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject | null): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // Warning: (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+namespace EntityStore {
+    // (undocumented)
+    class Root extends EntityStore {
+        constructor({ policies, resultCaching, seed, }: {
+            policies: Policies;
+            resultCaching?: boolean;
+            seed?: NormalizedCacheObject;
+        });
+        // (undocumented)
+        addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+        // (undocumented)
+        getStorage(): StorageType;
+        // (undocumented)
+        removeLayer(): Root;
+        // (undocumented)
+        readonly storageTrie: Trie<StorageType>;
+        // Warning: (ae-forgotten-export) The symbol "Stump" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        readonly stump: Stump;
+    }
+}
+
+// @public (undocumented)
+export type ErrorPolicy = "none" | "ignore" | "all";
+
+// @public (undocumented)
+export const execute: typeof ApolloLink.execute;
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+export interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// @public (undocumented)
+export type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+export const fallbackHttpConfig: {
+    http: HttpQueryOptions;
+    headers: {
+        accept: string;
+        "content-type": string;
+    };
+    options: {
+        method: string;
+    };
+};
+
+// @public (undocumented)
+export interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {
+    // (undocumented)
+    updateQuery?: (previousQueryResult: TData, options: {
+        fetchMoreResult?: TData;
+        variables?: TVariables;
+    }) => TData;
+}
+
+// @public (undocumented)
+export interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+export type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// @public (undocumented)
+export type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+export interface FieldFunctionOptions<TArgs = Record<string, any>, TVars = Record<string, any>> {
+    // (undocumented)
+    args: TArgs | null;
+    // (undocumented)
+    cache: InMemoryCache;
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    field: FieldNode | null;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    isReference: typeof isReference;
+    // Warning: (ae-forgotten-export) The symbol "MergeObjectsFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    mergeObjects: MergeObjectsFunction;
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField: ReadFieldFunction;
+    // (undocumented)
+    storage: StorageType;
+    // (undocumented)
+    storeFieldName: string;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+    // (undocumented)
+    variables?: TVars;
+}
+
+// @public (undocumented)
+export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
+
+// @public (undocumented)
+export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
+    keyArgs?: KeySpecifier | KeyArgsFunction | false;
+    read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
+    merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
+};
+
+// @public (undocumented)
+export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "EntityStore" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FieldValueGetter = EntityStore["getFieldValue"];
+
+// Warning: (ae-forgotten-export) The symbol "WriteContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FlavorableWriteContext = Pick<WriteContext, "clientOnly" | "deferred" | "flavors">;
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMapFunction = (fragmentName: string) => FragmentDefinitionNode | null;
+
+// @public (undocumented)
+export type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+interface FragmentRegistryAPI {
+    // (undocumented)
+    lookup(fragmentName: string): FragmentDefinitionNode | null;
+    // (undocumented)
+    register(...fragments: DocumentNode[]): this;
+    // (undocumented)
+    transform<D extends DocumentNode>(document: D): D;
+}
+
+// @public (undocumented)
+export const from: typeof ApolloLink.from;
+
+// @public (undocumented)
+export function fromError<T>(errorValue: any): Observable<T>;
+
+// @public (undocumented)
+export function fromPromise<T>(promise: Promise<T>): Observable<T>;
+
+export { gql }
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+export interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface HttpConfig {
+    // (undocumented)
+    credentials?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    http?: HttpQueryOptions;
+    // (undocumented)
+    options?: any;
+}
+
+// @public (undocumented)
+export class HttpLink extends ApolloLink {
+    constructor(options?: HttpOptions);
+    // (undocumented)
+    options: HttpOptions;
+    // (undocumented)
+    requester: RequestHandler;
+}
+
+// @public (undocumented)
+export interface HttpOptions {
+    // (undocumented)
+    credentials?: string;
+    // (undocumented)
+    fetch?: WindowOrWorkerGlobalScope["fetch"];
+    // (undocumented)
+    fetchOptions?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeUnusedVariables?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+    // (undocumented)
+    print?: Printer;
+    // (undocumented)
+    uri?: string | UriFunction;
+    // (undocumented)
+    useGETForQueries?: boolean;
+}
+
+// @public (undocumented)
+interface HttpQueryOptions {
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeQuery?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+}
+
+// @public (undocumented)
+export type IdGetter = (value: IdGetterObj) => string | undefined;
+
+// @public (undocumented)
+export interface IdGetterObj extends Object {
+    // (undocumented)
+    __typename?: string;
+    // (undocumented)
+    id?: string;
+    // (undocumented)
+    _id?: string;
+}
+
+// @public (undocumented)
+export interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+export class InMemoryCache extends ApolloCache<NormalizedCacheObject> {
+    constructor(config?: InMemoryCacheConfig);
+    // (undocumented)
+    readonly assumeImmutableResults = true;
+    // (undocumented)
+    batch<TUpdateResult>(options: Cache_2.BatchOptions<InMemoryCache, TUpdateResult>): TUpdateResult;
+    // Warning: (ae-forgotten-export) The symbol "BroadcastOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected broadcastWatches(options?: BroadcastOptions): void;
+    // (undocumented)
+    protected config: InMemoryCacheConfig;
+    // (undocumented)
+    diff<TData, TVariables extends OperationVariables = any>(options: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    extract(optimistic?: boolean): NormalizedCacheObject;
+    // (undocumented)
+    gc(options?: {
+        resetResultCache?: boolean;
+        resetResultIdentities?: boolean;
+    }): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    readonly makeVar: typeof makeVar;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any;
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    read<T>(options: Cache_2.ReadOptions): T | null;
+    // (undocumented)
+    release(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    removeOptimistic(idToRemove: string): void;
+    // (undocumented)
+    reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    restore(data: NormalizedCacheObject): this;
+    // (undocumented)
+    retain(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    write(options: Cache_2.WriteOptions): Reference | undefined;
+}
+
+// @public (undocumented)
+export interface InMemoryCacheConfig extends ApolloReducerConfig {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FragmentRegistryAPI" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fragments?: FragmentRegistryAPI;
+    // (undocumented)
+    possibleTypes?: PossibleTypesMap;
+    // (undocumented)
+    resultCacheMaxSize?: number;
+    // (undocumented)
+    resultCaching?: boolean;
+    // (undocumented)
+    typePolicies?: TypePolicies;
+}
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+export type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+export interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// @public (undocumented)
+export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+export function isApolloError(err: Error): err is ApolloError;
+
+// @public (undocumented)
+export function isNetworkRequestSettled(networkStatus?: NetworkStatus): boolean;
+
+// @public (undocumented)
+export function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+type KeyArgsFunction = (args: Record<string, any> | null, context: {
+    typename: string;
+    fieldName: string;
+    field: FieldNode | null;
+    variables?: Record<string, any>;
+}) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeyFieldsContext = {
+    typename: string | undefined;
+    storeObject: StoreObject;
+    readField: ReadFieldFunction;
+    selectionSet?: SelectionSetNode;
+    fragmentMap?: FragmentMap;
+    keyObject?: Record<string, any>;
+};
+
+// @public (undocumented)
+type KeyFieldsFunction = (object: Readonly<StoreObject>, context: KeyFieldsContext) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeySpecifier = ReadonlyArray<string | KeySpecifier>;
+
+// @public (undocumented)
+class Layer extends EntityStore {
+    constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup);
+    // (undocumented)
+    addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    getStorage(): StorageType;
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly parent: EntityStore;
+    // (undocumented)
+    removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    readonly replay: (layer: EntityStore) => any;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+}
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+export function makeReference(id: string): Reference;
+
+// @public (undocumented)
+export function makeVar<T>(value: T): ReactiveVar<T>;
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+export interface MergeInfo {
+    // (undocumented)
+    field: FieldNode;
+    // (undocumented)
+    merge: FieldMergeFunction;
+    // (undocumented)
+    typename: string | undefined;
+}
+
+// @public (undocumented)
+type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;
+
+// Warning: (ae-forgotten-export) The symbol "OptionsUnion" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function mergeOptions<TDefaultOptions extends Partial<OptionsUnion<any, any, any>>, TOptions extends TDefaultOptions>(defaults: TDefaultOptions | Partial<TDefaultOptions> | undefined, options: TOptions | Partial<TOptions>): TOptions & TDefaultOptions;
+
+// @public (undocumented)
+export interface MergeTree {
+    // (undocumented)
+    info?: MergeInfo;
+    // (undocumented)
+    map: Map<string | number, MergeTree>;
+}
+
+// @public (undocumented)
+export type MethodKeys<T> = {
+    [P in keyof T]: T[P] extends Function ? P : never;
+}[keyof T];
+
+// @public (undocumented)
+export class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+export type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export type MutationUpdaterFn<T = {
+    [key: string]: any;
+}> = (cache: ApolloCache<T>, mutationResult: FetchResult<T>) => void;
+
+// @public (undocumented)
+export type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+export enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+export type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+export interface NormalizedCache {
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string): boolean;
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "FieldValueGetter" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: FieldValueGetter;
+    // (undocumented)
+    getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    merge(olderId: string, newerObject: StoreObject): void;
+    // (undocumented)
+    merge(olderObject: StoreObject, newerId: string): void;
+    // (undocumented)
+    modify<Entity extends Record<string, any>>(dataId: string, fields: Modifiers<Entity> | AllFieldsModifier<Entity>): boolean;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+export interface NormalizedCacheObject {
+    // (undocumented)
+    [dataId: string]: StoreObject | undefined;
+    // (undocumented)
+    __META?: {
+        extraRootIds: string[];
+    };
+}
+
+export { Observable }
+
+// @public (undocumented)
+export class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): ObservableSubscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): ObservableSubscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+export { ObservableSubscription }
+
+export { Observer }
+
+// @public (undocumented)
+export type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+export interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+export type OptimisticStoreItem = {
+    id: string;
+    data: NormalizedCacheObject;
+    transaction: Transaction<NormalizedCacheObject>;
+};
+
+// @public (undocumented)
+type OptionsUnion<TData, TVariables extends OperationVariables, TContext> = WatchQueryOptions<TVariables, TData> | QueryOptions<TVariables, TData> | MutationOptions<TData, TVariables, TContext>;
+
+// @public (undocumented)
+export function parseAndCheckHttpResponse(operations: Operation | Operation[]): (response: Response) => Promise<any>;
+
+// @public (undocumented)
+export type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+class Policies {
+    constructor(config: {
+        cache: InMemoryCache;
+        dataIdFromObject?: KeyFieldsFunction;
+        possibleTypes?: PossibleTypesMap;
+        typePolicies?: TypePolicies;
+    });
+    // (undocumented)
+    addPossibleTypes(possibleTypes: PossibleTypesMap): void;
+    // (undocumented)
+    addTypePolicies(typePolicies: TypePolicies): void;
+    // (undocumented)
+    readonly cache: InMemoryCache;
+    // (undocumented)
+    fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string | undefined, result?: Record<string, any>, variables?: Record<string, any>): boolean;
+    // (undocumented)
+    getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
+    // (undocumented)
+    getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
+    // Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getStoreFieldName(fieldSpec: FieldSpecifier): string;
+    // (undocumented)
+    hasKeyArgs(typename: string | undefined, fieldName: string): boolean;
+    // (undocumented)
+    identify(object: StoreObject, partialContext?: Partial<KeyFieldsContext>): [string?, StoreObject?];
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
+    // (undocumented)
+    readonly rootIdsByTypename: Record<string, string>;
+    // (undocumented)
+    readonly rootTypenamesById: Record<string, string>;
+    // (undocumented)
+    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
+    // (undocumented)
+    readonly usingPossibleTypes = false;
+}
+
+// @public (undocumented)
+export type PossibleTypesMap = {
+    [supertype: string]: string[];
+};
+
+// @public (undocumented)
+const print_2: typeof print_3;
+
+// @public (undocumented)
+interface Printer {
+    // Warning: (ae-forgotten-export) The symbol "print_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    (node: ASTNode, originalPrint: typeof print_2): string;
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<ObservableSubscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+export type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+export { QueryOptions as PureQueryOptions }
+export { QueryOptions }
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+type ReactiveListener<T> = (value: T) => any;
+
+// @public (undocumented)
+export interface ReactiveVar<T> {
+    // (undocumented)
+    (newValue?: T): T;
+    // (undocumented)
+    attachCache(cache: ApolloCache<any>): this;
+    // (undocumented)
+    forgetCache(cache: ApolloCache<any>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onNextChange(listener: ReactiveListener<T>): () => void;
+}
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+export interface ReadMergeModifyContext {
+    // (undocumented)
+    store: NormalizedCache;
+    // (undocumented)
+    variables?: Record<string, any>;
+    // (undocumented)
+    varString?: string;
+}
+
+// @public (undocumented)
+export type ReadQueryOptions = {
+    store: NormalizedCache;
+    query: DocumentNode;
+    variables?: Object;
+    previousResult?: any;
+    canonizeResults?: boolean;
+    rootId?: string;
+    config?: ApolloReducerConfig;
+};
+
+// @public (undocumented)
+export interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+export interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// @public (undocumented)
+export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+export type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+export type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+export { resetCaches }
+
+// @public (undocumented)
+export type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+export interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// Warning: (ae-forgotten-export) The symbol "Body_2" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function rewriteURIForGET(chosenURI: string, body: Body_2): {
+    parseError: any;
+    newURI?: undefined;
+} | {
+    newURI: string;
+    parseError?: undefined;
+};
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// Warning: (ae-forgotten-export) The symbol "HttpConfig" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function selectHttpOptionsAndBody(operation: Operation, fallbackConfig: HttpConfig, ...configs: Array<HttpConfig>): {
+    options: HttpConfig & Record<string, any>;
+    body: Body_2;
+};
+
+// @public (undocumented)
+export function selectHttpOptionsAndBodyInternal(operation: Operation, printer: Printer, ...configs: HttpConfig[]): {
+    options: HttpConfig & Record<string, any>;
+    body: Body_2;
+};
+
+// @public (undocumented)
+export const selectURI: (operation: Operation, fallbackURI?: string | ((operation: Operation) => string) | undefined) => any;
+
+// @public (undocumented)
+export const serializeFetchParameter: (p: any, label: string) => string;
+
+// @public (undocumented)
+export type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+export type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+export { setLogVerbosity }
+
+// @public (undocumented)
+export interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+export const split: typeof ApolloLink.split;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+export interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+export type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+class Stump extends Layer {
+    constructor(root: EntityStore.Root);
+    // (undocumented)
+    merge(): any;
+    // (undocumented)
+    removeLayer(): this;
+}
+
+// @public (undocumented)
+export type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+export interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export const throwServerError: (response: Response, result: any, message: string) => never;
+
+// @public (undocumented)
+export function toPromise<R>(observable: Observable<R>): Promise<R>;
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+export type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+export { TypedDocumentNode }
+
+// @public (undocumented)
+export type TypePolicies = {
+    [__typename: string]: TypePolicy;
+};
+
+// @public (undocumented)
+export type TypePolicy = {
+    keyFields?: KeySpecifier | KeyFieldsFunction | false;
+    merge?: FieldMergeFunction | boolean;
+    queryType?: true;
+    mutationType?: true;
+    subscriptionType?: true;
+    fields?: {
+        [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
+    };
+};
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+export interface UpdateQueryOptions<TVariables> {
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+export interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// @public (undocumented)
+interface WriteContext extends ReadMergeModifyContext {
+    // (undocumented)
+    clientOnly: boolean;
+    // (undocumented)
+    deferred: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FlavorableWriteContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    flavors: Map<string, FlavorableWriteContext>;
+    // (undocumented)
+    readonly fragmentMap: FragmentMap;
+    // (undocumented)
+    incomingById: Map<string, {
+        storeObject: StoreObject;
+        mergeTree?: MergeTree;
+        fieldNodeSet: Set<FieldNode>;
+    }>;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMapFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    lookupFragment: FragmentMapFunction;
+    // (undocumented)
+    merge<T>(existing: T, incoming: T): T;
+    // (undocumented)
+    overwrite: boolean;
+    // (undocumented)
+    readonly written: {
+        [dataId: string]: SelectionSetNode[];
+    };
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/inmemory/policies.ts:98:3 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeySpecifier" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeyArgsFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/types.ts:126:3 - (ae-forgotten-export) The symbol "KeyFieldsFunction" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/link/http/selectHttpOptionsAndBody.ts:128:32 - (ae-forgotten-export) The symbol "HttpQueryOptions" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-dev.md b/.api-reports/api-report-dev.md
new file mode 100644
index 00000000000..8f5baa9c781
--- /dev/null
+++ b/.api-reports/api-report-dev.md
@@ -0,0 +1,30 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public (undocumented)
+interface ErrorCodes {
+    // (undocumented)
+    [key: number]: {
+        file: string;
+        condition?: string;
+        message?: string;
+    };
+}
+
+// @public (undocumented)
+export function loadDevMessages(): void;
+
+// Warning: (ae-forgotten-export) The symbol "ErrorCodes" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function loadErrorMessageHandler(...errorCodes: ErrorCodes[]): ((message: string | number, args: unknown[]) => string | undefined) & ErrorCodes;
+
+// @public (undocumented)
+export function loadErrorMessages(): void;
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-errors.md b/.api-reports/api-report-errors.md
new file mode 100644
index 00000000000..205b170bf0f
--- /dev/null
+++ b/.api-reports/api-report-errors.md
@@ -0,0 +1,174 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+
+// @public (undocumented)
+export class ApolloError extends Error {
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+export interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResultWithSymbolExtensions<T> = FetchResult<T> & {
+    extensions: Record<string | symbol, any>;
+};
+
+// @public (undocumented)
+export type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// Warning: (ae-forgotten-export) The symbol "FetchResultWithSymbolExtensions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function graphQLResultHasProtocolErrors<T>(result: FetchResult<T>): result is FetchResultWithSymbolExtensions<T>;
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+export function isApolloError(err: Error): err is ApolloError;
+
+// @public (undocumented)
+export type NetworkError = Error | ServerParseError | ServerError | null;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+export const PROTOCOL_ERRORS_SYMBOL: unique symbol;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_batch-http.md b/.api-reports/api-report-link_batch-http.md
new file mode 100644
index 00000000000..0e39566b61a
--- /dev/null
+++ b/.api-reports/api-report-link_batch-http.md
@@ -0,0 +1,258 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import { print as print_3 } from 'graphql';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type BatchHandler = (operations: Operation[], forward?: (NextLink | undefined)[]) => Observable<FetchResult[]> | null;
+
+// @public (undocumented)
+export namespace BatchHttpLink {
+    // Warning: (ae-forgotten-export) The symbol "BatchLink" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "HttpOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    export type Options = Pick<BatchLink.Options, "batchMax" | "batchDebounce" | "batchInterval" | "batchKey"> & Omit<HttpOptions, "useGETForQueries">;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class BatchHttpLink extends ApolloLink {
+    constructor(fetchParams?: BatchHttpLink.Options);
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult> | null;
+}
+
+// @public (undocumented)
+namespace BatchLink {
+    // (undocumented)
+    interface Options {
+        // (undocumented)
+        batchDebounce?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "BatchHandler" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        batchHandler?: BatchHandler;
+        // (undocumented)
+        batchInterval?: number;
+        // (undocumented)
+        batchKey?: (operation: Operation) => string;
+        // (undocumented)
+        batchMax?: number;
+    }
+}
+
+// @public (undocumented)
+class BatchLink extends ApolloLink {
+    constructor(fetchParams?: BatchLink.Options);
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface HttpOptions {
+    // (undocumented)
+    credentials?: string;
+    // (undocumented)
+    fetch?: WindowOrWorkerGlobalScope["fetch"];
+    // (undocumented)
+    fetchOptions?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeUnusedVariables?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+    // Warning: (ae-forgotten-export) The symbol "Printer" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    print?: Printer;
+    // Warning: (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    uri?: string | UriFunction;
+    // (undocumented)
+    useGETForQueries?: boolean;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+const print_2: typeof print_3;
+
+// @public (undocumented)
+interface Printer {
+    // Warning: (ae-forgotten-export) The symbol "print_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    (node: ASTNode, originalPrint: typeof print_2): string;
+}
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_batch.md b/.api-reports/api-report-link_batch.md
new file mode 100644
index 00000000000..ecc43997ee7
--- /dev/null
+++ b/.api-reports/api-report-link_batch.md
@@ -0,0 +1,216 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+export interface BatchableRequest {
+    // (undocumented)
+    forward?: NextLink;
+    // (undocumented)
+    operation: Operation;
+}
+
+// @public (undocumented)
+export type BatchHandler = (operations: Operation[], forward?: (NextLink | undefined)[]) => Observable<FetchResult[]> | null;
+
+// @public (undocumented)
+export namespace BatchLink {
+    // (undocumented)
+    export interface Options {
+        // (undocumented)
+        batchDebounce?: boolean;
+        // (undocumented)
+        batchHandler?: BatchHandler;
+        // (undocumented)
+        batchInterval?: number;
+        // (undocumented)
+        batchKey?: (operation: Operation) => string;
+        // (undocumented)
+        batchMax?: number;
+    }
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class BatchLink extends ApolloLink {
+    constructor(fetchParams?: BatchLink.Options);
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export class OperationBatcher {
+    constructor({ batchDebounce, batchInterval, batchMax, batchHandler, batchKey, }: {
+        batchDebounce?: boolean;
+        batchInterval?: number;
+        batchMax?: number;
+        batchHandler: BatchHandler;
+        batchKey?: (operation: Operation) => string;
+    });
+    // (undocumented)
+    consumeQueue(key?: string): (Observable<FetchResult> | undefined)[] | undefined;
+    // (undocumented)
+    enqueueRequest(request: BatchableRequest): Observable<FetchResult>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_context.md b/.api-reports/api-report-link_context.md
new file mode 100644
index 00000000000..bd2790f5381
--- /dev/null
+++ b/.api-reports/api-report-link_context.md
@@ -0,0 +1,172 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type ContextSetter = (operation: GraphQLRequest, prevContext: DefaultContext) => Promise<DefaultContext> | DefaultContext;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function setContext(setter: ContextSetter): ApolloLink;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_core.md b/.api-reports/api-report-link_core.md
new file mode 100644
index 00000000000..e711dfe7fc1
--- /dev/null
+++ b/.api-reports/api-report-link_core.md
@@ -0,0 +1,170 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+export class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+export interface ApolloPayloadResult<TData = Record<string, any>, TExtensions = Record<string, any>> {
+    // (undocumented)
+    errors?: ReadonlyArray<Error | string>;
+    // (undocumented)
+    payload: SingleExecutionResult | ExecutionPatchResult | null;
+}
+
+// @public (undocumented)
+export const concat: typeof ApolloLink.concat;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+export { DocumentNode }
+
+// @public (undocumented)
+export const empty: typeof ApolloLink.empty;
+
+// @public (undocumented)
+export const execute: typeof ApolloLink.execute;
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+export interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// @public (undocumented)
+export type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+export type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+export const from: typeof ApolloLink.from;
+
+// @public (undocumented)
+export interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+export type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+export interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+export type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+export interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export const split: typeof ApolloLink.split;
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_error.md b/.api-reports/api-report-link_error.md
new file mode 100644
index 00000000000..71bb22bc33a
--- /dev/null
+++ b/.api-reports/api-report-link_error.md
@@ -0,0 +1,232 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// (undocumented)
+export interface ErrorHandler {
+    // (undocumented)
+    (error: ErrorResponse): Observable<FetchResult> | void;
+}
+
+// @public (undocumented)
+export namespace ErrorLink {
+    // (undocumented)
+    export interface ErrorHandler {
+        // (undocumented)
+        (error: ErrorResponse): Observable<FetchResult> | void;
+    }
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class ErrorLink extends ApolloLink {
+    constructor(errorHandler: ErrorLink.ErrorHandler);
+    // (undocumented)
+    request(operation: Operation, forward: NextLink): Observable<FetchResult> | null;
+}
+
+// @public (undocumented)
+export interface ErrorResponse {
+    // (undocumented)
+    forward: NextLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors?: GraphQLErrors;
+    // Warning: (ae-forgotten-export) The symbol "NetworkError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError?: NetworkError;
+    // (undocumented)
+    operation: Operation;
+    // (undocumented)
+    response?: ExecutionResult;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type NetworkError = Error | ServerParseError | ServerError | null;
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+export function onError(errorHandler: ErrorHandler): ApolloLink;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_http.md b/.api-reports/api-report-link_http.md
new file mode 100644
index 00000000000..09b1e6459dd
--- /dev/null
+++ b/.api-reports/api-report-link_http.md
@@ -0,0 +1,335 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { InvariantError } from 'ts-invariant';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import { print as print_3 } from 'graphql';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface Body_2 {
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+export const checkFetcher: (fetcher: WindowOrWorkerGlobalScope["fetch"] | undefined) => void;
+
+// @public (undocumented)
+export type ClientParseError = InvariantError & {
+    parseError: Error;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const createHttpLink: (linkOptions?: HttpOptions) => ApolloLink;
+
+// @public (undocumented)
+export const createSignalIfSupported: () => {
+    controller: boolean;
+    signal: boolean;
+} | {
+    controller: AbortController;
+    signal: AbortSignal;
+};
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "Printer" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const defaultPrinter: Printer;
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+export const fallbackHttpConfig: {
+    http: HttpQueryOptions;
+    headers: {
+        accept: string;
+        "content-type": string;
+    };
+    options: {
+        method: string;
+    };
+};
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface HttpConfig {
+    // (undocumented)
+    credentials?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    http?: HttpQueryOptions;
+    // (undocumented)
+    options?: any;
+}
+
+// @public (undocumented)
+export class HttpLink extends ApolloLink {
+    constructor(options?: HttpOptions);
+    // (undocumented)
+    options: HttpOptions;
+    // (undocumented)
+    requester: RequestHandler;
+}
+
+// @public (undocumented)
+export interface HttpOptions {
+    // (undocumented)
+    credentials?: string;
+    // (undocumented)
+    fetch?: WindowOrWorkerGlobalScope["fetch"];
+    // (undocumented)
+    fetchOptions?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeUnusedVariables?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+    // (undocumented)
+    print?: Printer;
+    // (undocumented)
+    uri?: string | UriFunction;
+    // (undocumented)
+    useGETForQueries?: boolean;
+}
+
+// @public (undocumented)
+interface HttpQueryOptions {
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeQuery?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export function parseAndCheckHttpResponse(operations: Operation | Operation[]): (response: Response) => Promise<any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+const print_2: typeof print_3;
+
+// @public (undocumented)
+interface Printer {
+    // Warning: (ae-forgotten-export) The symbol "print_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    (node: ASTNode, originalPrint: typeof print_2): string;
+}
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// Warning: (ae-forgotten-export) The symbol "Body_2" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function rewriteURIForGET(chosenURI: string, body: Body_2): {
+    parseError: any;
+    newURI?: undefined;
+} | {
+    newURI: string;
+    parseError?: undefined;
+};
+
+// Warning: (ae-forgotten-export) The symbol "HttpConfig" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function selectHttpOptionsAndBody(operation: Operation, fallbackConfig: HttpConfig, ...configs: Array<HttpConfig>): {
+    options: HttpConfig & Record<string, any>;
+    body: Body_2;
+};
+
+// @public (undocumented)
+export function selectHttpOptionsAndBodyInternal(operation: Operation, printer: Printer, ...configs: HttpConfig[]): {
+    options: HttpConfig & Record<string, any>;
+    body: Body_2;
+};
+
+// @public (undocumented)
+export const selectURI: (operation: Operation, fallbackURI?: string | ((operation: Operation) => string) | undefined) => any;
+
+// @public (undocumented)
+export const serializeFetchParameter: (p: any, label: string) => string;
+
+// @public (undocumented)
+export type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// Warnings were encountered during analysis:
+//
+// src/link/http/selectHttpOptionsAndBody.ts:128:32 - (ae-forgotten-export) The symbol "HttpQueryOptions" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_persisted-queries.md b/.api-reports/api-report-link_persisted-queries.md
new file mode 100644
index 00000000000..dda0d3dd1db
--- /dev/null
+++ b/.api-reports/api-report-link_persisted-queries.md
@@ -0,0 +1,259 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface BaseOptions {
+    // (undocumented)
+    disable?: (error: ErrorResponse) => boolean;
+    // (undocumented)
+    retry?: (error: ErrorResponse) => boolean;
+    // (undocumented)
+    useGETForHashedQueries?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const createPersistedQueryLink: (options: PersistedQueryLink.Options) => ApolloLink;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+type ErrorMeta = {
+    persistedQueryNotSupported: boolean;
+    persistedQueryNotFound: boolean;
+};
+
+// @public (undocumented)
+export interface ErrorResponse {
+    // (undocumented)
+    graphQLErrors?: readonly GraphQLError[];
+    // Warning: (ae-forgotten-export) The symbol "ErrorMeta" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    meta: ErrorMeta;
+    // Warning: (ae-forgotten-export) The symbol "NetworkError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError?: NetworkError;
+    // (undocumented)
+    operation: Operation;
+    // (undocumented)
+    response?: ExecutionResult;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+type GenerateHashFunction = (document: DocumentNode) => string | PromiseLike<string>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type NetworkError = Error | ServerParseError | ServerError | null;
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+export namespace PersistedQueryLink {
+    // (undocumented)
+    export interface GenerateHashOptions extends BaseOptions {
+        // Warning: (ae-forgotten-export) The symbol "GenerateHashFunction" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        generateHash: GenerateHashFunction;
+        // (undocumented)
+        sha256?: never;
+    }
+    // (undocumented)
+    export type Options = SHA256Options | GenerateHashOptions;
+    // Warning: (ae-forgotten-export) The symbol "BaseOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    export interface SHA256Options extends BaseOptions {
+        // (undocumented)
+        generateHash?: never;
+        // Warning: (ae-forgotten-export) The symbol "SHA256Function" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        sha256: SHA256Function;
+    }
+        {};
+}
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+type SHA256Function = (...args: any[]) => string | PromiseLike<string>;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export const VERSION = 1;
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_remove-typename.md b/.api-reports/api-report-link_remove-typename.md
new file mode 100644
index 00000000000..ddec205b0ac
--- /dev/null
+++ b/.api-reports/api-report-link_remove-typename.md
@@ -0,0 +1,186 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+export const KEEP = "__KEEP";
+
+// @public (undocumented)
+interface KeepTypenameConfig {
+    // (undocumented)
+    [key: string]: typeof KEEP | KeepTypenameConfig;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function removeTypenameFromVariables(options?: RemoveTypenameFromVariablesOptions): ApolloLink;
+
+// @public (undocumented)
+export interface RemoveTypenameFromVariablesOptions {
+    // Warning: (ae-forgotten-export) The symbol "KeepTypenameConfig" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    except?: KeepTypenameConfig;
+}
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_retry.md b/.api-reports/api-report-link_retry.md
new file mode 100644
index 00000000000..a4ce34c4e29
--- /dev/null
+++ b/.api-reports/api-report-link_retry.md
@@ -0,0 +1,220 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DelayFunction {
+    // (undocumented)
+    (count: number, operation: Operation, error: any): number;
+}
+
+// @public (undocumented)
+interface DelayFunctionOptions {
+    // (undocumented)
+    initial?: number;
+    // (undocumented)
+    jitter?: boolean;
+    // (undocumented)
+    max?: number;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+interface RetryFunction {
+    // (undocumented)
+    (count: number, operation: Operation, error: any): boolean | Promise<boolean>;
+}
+
+// @public (undocumented)
+interface RetryFunctionOptions {
+    // (undocumented)
+    max?: number;
+    // (undocumented)
+    retryIf?: (error: any, operation: Operation) => boolean | Promise<boolean>;
+}
+
+// @public (undocumented)
+export namespace RetryLink {
+    // (undocumented)
+    export interface Options {
+        // Warning: (ae-forgotten-export) The symbol "RetryFunctionOptions" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "RetryFunction" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        attempts?: RetryFunctionOptions | RetryFunction;
+        // Warning: (ae-forgotten-export) The symbol "DelayFunctionOptions" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "DelayFunction" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        delay?: DelayFunctionOptions | DelayFunction;
+    }
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class RetryLink extends ApolloLink {
+    constructor(options?: RetryLink.Options);
+    // (undocumented)
+    request(operation: Operation, nextLink: NextLink): Observable<FetchResult>;
+}
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_schema.md b/.api-reports/api-report-link_schema.md
new file mode 100644
index 00000000000..676e4338cb9
--- /dev/null
+++ b/.api-reports/api-report-link_schema.md
@@ -0,0 +1,201 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLSchema } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+export namespace SchemaLink {
+    // (undocumented)
+    export interface Options {
+        // (undocumented)
+        context?: ResolverContext | ResolverContextFunction;
+        // (undocumented)
+        rootValue?: any;
+        // (undocumented)
+        schema: GraphQLSchema;
+        // (undocumented)
+        validate?: boolean;
+    }
+    // (undocumented)
+    export type ResolverContext = Record<string, any>;
+    // (undocumented)
+    export type ResolverContextFunction = (operation: Operation) => ResolverContext | PromiseLike<ResolverContext>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class SchemaLink extends ApolloLink {
+    constructor(options: SchemaLink.Options);
+    // (undocumented)
+    context: SchemaLink.Options["context"];
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult>;
+    // (undocumented)
+    rootValue: SchemaLink.Options["rootValue"];
+    // (undocumented)
+    schema: SchemaLink.Options["schema"];
+    // (undocumented)
+    validate: boolean;
+}
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_subscriptions.md b/.api-reports/api-report-link_subscriptions.md
new file mode 100644
index 00000000000..5b5e1585f6e
--- /dev/null
+++ b/.api-reports/api-report-link_subscriptions.md
@@ -0,0 +1,176 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { Client } from 'graphql-ws';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class GraphQLWsLink extends ApolloLink {
+    constructor(client: Client);
+    // (undocumented)
+    readonly client: Client;
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult>;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_utils.md b/.api-reports/api-report-link_utils.md
new file mode 100644
index 00000000000..061cad690e5
--- /dev/null
+++ b/.api-reports/api-report-link_utils.md
@@ -0,0 +1,84 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+
+// Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function createOperation(starting: any, operation: GraphQLRequest): Operation;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+export function filterOperationVariables(variables: Record<string, any>, query: DocumentNode): {
+    [x: string]: any;
+};
+
+// @public (undocumented)
+export function fromError<T>(errorValue: any): Observable<T>;
+
+// @public (undocumented)
+export function fromPromise<T>(promise: Promise<T>): Observable<T>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+export const throwServerError: (response: Response, result: any, message: string) => never;
+
+// @public (undocumented)
+export function toPromise<R>(observable: Observable<R>): Promise<R>;
+
+// @public (undocumented)
+export function transformOperation(operation: GraphQLRequest): GraphQLRequest;
+
+// @public (undocumented)
+export function validateOperation(operation: GraphQLRequest): GraphQLRequest;
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-link_ws.md b/.api-reports/api-report-link_ws.md
new file mode 100644
index 00000000000..b746ad6a2db
--- /dev/null
+++ b/.api-reports/api-report-link_ws.md
@@ -0,0 +1,198 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ClientOptions } from 'subscriptions-transport-ws';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import { SubscriptionClient } from 'subscriptions-transport-ws';
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export namespace WebSocketLink {
+    // (undocumented)
+    export interface WebSocketParams {
+        // (undocumented)
+        options?: ClientOptions;
+        // (undocumented)
+        uri: string;
+        // (undocumented)
+        webSocketImpl?: any;
+    }
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class WebSocketLink extends ApolloLink {
+    constructor(paramsOrClient: WebSocketLink.Configuration | SubscriptionClient);
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult> | null;
+}
+
+// (undocumented)
+export interface WebSocketParams {
+    // (undocumented)
+    options?: ClientOptions;
+    // (undocumented)
+    uri: string;
+    // (undocumented)
+    webSocketImpl?: any;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react.md b/.api-reports/api-report-react.md
new file mode 100644
index 00000000000..504453b9637
--- /dev/null
+++ b/.api-reports/api-report-react.md
@@ -0,0 +1,2237 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="react" />
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { VariableDefinitionNode } from 'graphql';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    mutate<TData = any, TVariables extends OperationVariables = OperationVariables, TContext extends Record<string, any> = Context, TCache extends ApolloCache<any> = ApolloCache<any>>(options: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ApolloConsumerProps" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const ApolloConsumer: React_2.FC<ApolloConsumerProps>;
+
+// @public (undocumented)
+interface ApolloConsumerProps {
+    // Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    children: (client: ApolloClient<object>) => React_2.ReactChild | null;
+}
+
+// @public (undocumented)
+export interface ApolloContextValue {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // Warning: (ae-forgotten-export) The symbol "RenderPromises" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    renderPromises?: RenderPromises;
+}
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloProviderProps" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const ApolloProvider: React_2.FC<ApolloProviderProps<any>>;
+
+// @public (undocumented)
+interface ApolloProviderProps<TCache> {
+    // (undocumented)
+    children: React_2.ReactNode | React_2.ReactNode[] | null;
+    // (undocumented)
+    client: ApolloClient<TCache>;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type BackgroundQueryHookFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
+
+// @public (undocumented)
+export interface BackgroundQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick<QueryHookOptions<TData, TVariables>, "client" | "variables" | "errorPolicy" | "context" | "canonizeResults" | "returnPartialData" | "refetchWritePolicy"> {
+    // (undocumented)
+    fetchPolicy?: BackgroundQueryHookFetchPolicy;
+    // (undocumented)
+    queryKey?: string | number | any[];
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    suspenseCache?: SuspenseCache;
+}
+
+// @public (undocumented)
+type BackgroundQueryHookOptionsNoInfer<TData, TVariables extends OperationVariables> = BackgroundQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>;
+
+// @public (undocumented)
+export interface BaseMutationOptions<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, "mutation"> {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    ignoreResults?: boolean;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;
+    // (undocumented)
+    onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;
+}
+
+// @public (undocumented)
+export interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: Context;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+export interface BaseSubscriptionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    context?: Context;
+    // Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    onComplete?: () => void;
+    // (undocumented)
+    onData?: (options: OnDataOptions<TData>) => any;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    onSubscriptionComplete?: () => void;
+    // (undocumented)
+    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any;
+    // (undocumented)
+    shouldResubscribe?: boolean | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean);
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+type CacheKey = [
+query: DocumentNode,
+stringifiedVariables: string,
+...queryKey: any[]
+];
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+export type CommonOptions<TOptions> = TOptions & {
+    client?: ApolloClient<object>;
+};
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+export interface Context extends Record<string, any> {
+}
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartialPrimitive" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlyMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialSet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlySet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialObject" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartial<T> = T extends DeepPartialPrimitive ? T : T extends Map<infer TKey, infer TValue> ? DeepPartialMap<TKey, TValue> : T extends ReadonlyMap<infer TKey, infer TValue> ? DeepPartialReadonlyMap<TKey, TValue> : T extends Set<infer TItem> ? DeepPartialSet<TItem> : T extends ReadonlySet<infer TItem> ? DeepPartialReadonlySet<TItem> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends ReadonlyArray<infer TItem> ? TItem[] extends T ? readonly TItem[] extends T ? ReadonlyArray<DeepPartial<TItem | undefined>> : Array<DeepPartial<TItem | undefined>> : DeepPartialObject<T> : DeepPartialObject<T> : unknown;
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartial" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartialMap<TKey, TValue> = {} & Map<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialObject<T extends object> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Primitive" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartialPrimitive = Primitive | Date | RegExp;
+
+// @public (undocumented)
+type DeepPartialReadonlyMap<TKey, TValue> = {} & ReadonlyMap<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialReadonlySet<T> = {} & ReadonlySet<DeepPartial<T>>;
+
+// @public (undocumented)
+type DeepPartialSet<T> = {} & Set<DeepPartial<T>>;
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+enum DocumentType_2 {
+    // (undocumented)
+    Mutation = 1,
+    // (undocumented)
+    Query = 0,
+    // (undocumented)
+    Subscription = 2
+}
+export { DocumentType_2 as DocumentType }
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchMoreFunction<TData, TVariables extends OperationVariables> = (fetchMoreOptions: FetchMoreQueryOptions<TVariables, TData> & {
+    updateQuery?: (previousQueryResult: TData, options: {
+        fetchMoreResult: TData;
+        variables: TVariables;
+    }) => TData;
+}) => Promise<ApolloQueryResult<TData>>;
+
+// @public (undocumented)
+type FetchMoreOptions<TData> = Parameters<ObservableQuery<TData>["fetchMore"]>[0];
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: Context;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+export function getApolloContext(): React_2.Context<ApolloContextValue>;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: Context;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface IDocumentDefinition {
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    type: DocumentType_2;
+    // (undocumented)
+    variables: ReadonlyArray<VariableDefinitionNode>;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+class InternalQueryReference<TData = unknown> {
+    // Warning: (ae-forgotten-export) The symbol "InternalQueryReferenceOptions" needs to be exported by the entry point index.d.ts
+    constructor(observable: ObservableQuery<TData>, options: InternalQueryReferenceOptions);
+    // (undocumented)
+    applyOptions(watchQueryOptions: ObservedOptions): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "ObservedOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    didChangeOptions(watchQueryOptions: ObservedOptions): boolean;
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore(options: FetchMoreOptions<TData>): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "CacheKey" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly key: CacheKey;
+    // Warning: (ae-forgotten-export) The symbol "Listener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listen(listener: Listener<TData>): () => void;
+    // (undocumented)
+    readonly observable: ObservableQuery<TData>;
+    // (undocumented)
+    promise: Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    promiseCache?: Map<CacheKey, Promise<ApolloQueryResult<TData>>>;
+    // (undocumented)
+    refetch(variables: OperationVariables | undefined): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    result: ApolloQueryResult<TData>;
+    // (undocumented)
+    retain(): () => void;
+    // (undocumented)
+    get watchQueryOptions(): WatchQueryOptions<OperationVariables, TData>;
+}
+
+// @public (undocumented)
+interface InternalQueryReferenceOptions {
+    // (undocumented)
+    autoDisposeTimeoutMs?: number;
+    // (undocumented)
+    key: CacheKey;
+    // (undocumented)
+    onDispose?: () => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+export type LazyQueryExecFunction<TData, TVariables extends OperationVariables> = (options?: Partial<LazyQueryHookExecOptions<TData, TVariables>>) => Promise<QueryResult<TData, TVariables>>;
+
+// @public (undocumented)
+export interface LazyQueryHookExecOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends LazyQueryHookOptions<TData, TVariables> {
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface LazyQueryHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends Omit<QueryHookOptions<TData, TVariables>, "skip"> {
+}
+
+// @public (undocumented)
+export type LazyQueryResult<TData, TVariables extends OperationVariables> = QueryResult<TData, TVariables>;
+
+// @public (undocumented)
+export type LazyQueryResultTuple<TData, TVariables extends OperationVariables> = [LazyQueryExecFunction<TData, TVariables>, QueryResult<TData, TVariables>];
+
+// @public (undocumented)
+type Listener<TData> = (promise: Promise<ApolloQueryResult<TData>>) => void;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface MutationDataOptions<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// @public (undocumented)
+export type MutationFunction<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> = (options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>;
+
+// @public (undocumented)
+export interface MutationFunctionOptions<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface MutationHookOptions<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+export interface MutationResult<TData = any> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data?: TData | null;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    reset(): void;
+}
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export type MutationTuple<TData, TVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>> = [
+(options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>,
+MutationResult<TData>
+];
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+export type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<ObservableQuery<TData, TVariables>, "startPolling" | "stopPolling" | "subscribeToMore" | "updateQuery" | "refetch" | "reobserve" | "variables" | "fetchMore">;
+
+// @public (undocumented)
+const OBSERVED_CHANGED_OPTIONS: readonly ["canonizeResults", "context", "errorPolicy", "fetchPolicy", "refetchWritePolicy", "returnPartialData"];
+
+// Warning: (ae-forgotten-export) The symbol "OBSERVED_CHANGED_OPTIONS" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ObservedOptions = Pick<WatchQueryOptions, (typeof OBSERVED_CHANGED_OPTIONS)[number]>;
+
+// @public (undocumented)
+export interface OnDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+export interface OnSubscriptionDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    subscriptionData: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => Context;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: Context) => Context;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export function operationName(type: DocumentType_2): string;
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+export function parser(document: DocumentNode): IDocumentDefinition;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+
+// @public (undocumented)
+const QUERY_REFERENCE_SYMBOL: unique symbol;
+
+// @public (undocumented)
+interface QueryData {
+    // (undocumented)
+    fetchData(): Promise<void>;
+    // (undocumented)
+    getOptions(): any;
+}
+
+// @public (undocumented)
+export interface QueryDataOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+    // (undocumented)
+    children?: (result: QueryResult<TData, TVariables>) => ReactNode;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface QueryFunctionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {
+    // (undocumented)
+    defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
+    // (undocumented)
+    onCompleted?: (data: TData) => void;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    skip?: boolean;
+}
+
+// @public (undocumented)
+export interface QueryHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+export interface QueryLazyOptions<TVariables> {
+    // (undocumented)
+    context?: Context;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: Context;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface QueryReference<TData = unknown> {
+    // Warning: (ae-forgotten-export) The symbol "InternalQueryReference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    [QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData>;
+}
+
+// @public (undocumented)
+export interface QueryResult<TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData | undefined;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    previousData?: TData;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+export type QueryTuple<TData, TVariables extends OperationVariables> = LazyQueryResultTuple<TData, TVariables>;
+
+// @public (undocumented)
+type ReactiveListener<T> = (value: T) => any;
+
+// @public (undocumented)
+interface ReactiveVar<T> {
+    // (undocumented)
+    (newValue?: T): T;
+    // (undocumented)
+    attachCache(cache: ApolloCache<any>): this;
+    // (undocumented)
+    forgetCache(cache: ApolloCache<any>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onNextChange(listener: ReactiveListener<T>): () => void;
+}
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchFunction<TData, TVariables extends OperationVariables> = ObservableQueryFields<TData, TVariables>["refetch"];
+
+// @public (undocumented)
+export type RefetchQueriesFunction = (...args: any[]) => InternalRefetchQueriesInclude;
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+class RenderPromises {
+    // (undocumented)
+    addObservableQueryPromise<TData, TVariables extends OperationVariables>(obsQuery: ObservableQuery<TData, TVariables>): ReactNode;
+    // Warning: (ae-forgotten-export) The symbol "QueryData" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addQueryPromise(queryInstance: QueryData, finish?: () => React.ReactNode): React.ReactNode;
+    // (undocumented)
+    consumeAndAwaitPromises(): Promise<any[]>;
+    // (undocumented)
+    getSSRObservable<TData, TVariables extends OperationVariables>(props: QueryDataOptions<TData, TVariables>): ObservableQuery<any, TVariables> | null;
+    // (undocumented)
+    hasPromises(): boolean;
+    // (undocumented)
+    registerSSRObservable<TData, TVariables extends OperationVariables>(observable: ObservableQuery<any, TVariables>): void;
+    // (undocumented)
+    stop(): void;
+}
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+export const resetApolloContext: typeof getApolloContext;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = Context, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export type SkipToken = typeof skipToken;
+
+// @public (undocumented)
+export const skipToken: unique symbol;
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+type SubscribeToMoreFunction<TData, TVariables extends OperationVariables> = ObservableQueryFields<TData, TVariables>["subscribeToMore"];
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: Context;
+};
+
+// @public (undocumented)
+export interface SubscriptionCurrentObservable {
+    // (undocumented)
+    query?: Observable<any>;
+    // (undocumented)
+    subscription?: Subscription;
+}
+
+// @public (undocumented)
+export interface SubscriptionDataOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {
+    // (undocumented)
+    children?: null | ((result: SubscriptionResult<TData>) => JSX.Element | null);
+    // (undocumented)
+    subscription: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface SubscriptionHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {
+}
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: Context;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface SubscriptionResult<TData = any, TVariables = any> {
+    // (undocumented)
+    data?: TData;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SuspenseCache_2" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class SuspenseCache extends SuspenseCache_2 {
+    constructor();
+}
+
+// @public (undocumented)
+class SuspenseCache_2 {
+    // Warning: (ae-forgotten-export) The symbol "SuspenseCacheOptions" needs to be exported by the entry point index.d.ts
+    constructor(options?: SuspenseCacheOptions);
+    // (undocumented)
+    getQueryRef<TData = any>(cacheKey: CacheKey, createObservable: () => ObservableQuery<TData>): InternalQueryReference<TData>;
+}
+
+// @public (undocumented)
+interface SuspenseCacheOptions {
+    // (undocumented)
+    autoDisposeTimeoutMs?: number;
+}
+
+// @public (undocumented)
+export type SuspenseQueryHookFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
+
+// @public (undocumented)
+export interface SuspenseQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick<QueryHookOptions<TData, TVariables>, "client" | "variables" | "errorPolicy" | "context" | "canonizeResults" | "returnPartialData" | "refetchWritePolicy"> {
+    // (undocumented)
+    fetchPolicy?: SuspenseQueryHookFetchPolicy;
+    // (undocumented)
+    queryKey?: string | number | any[];
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    suspenseCache?: SuspenseCache;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export function useApolloClient(override?: ApolloClient<object>): ApolloClient<object>;
+
+// Warning: (ae-forgotten-export) The symbol "BackgroundQueryHookOptionsNoInfer" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useBackgroundQuery<TData, TVariables extends OperationVariables, TOptions extends Omit<BackgroundQueryHookOptions<TData>, "variables">>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & TOptions): [
+(QueryReference<TOptions["errorPolicy"] extends "ignore" | "all" ? TOptions["returnPartialData"] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions["returnPartialData"] extends true ? DeepPartial<TData> : TData> | (TOptions["skip"] extends boolean ? undefined : never)),
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+    errorPolicy: "ignore" | "all";
+}): [
+QueryReference<DeepPartial<TData> | undefined>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    errorPolicy: "ignore" | "all";
+}): [
+QueryReference<TData | undefined>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    skip: boolean;
+    returnPartialData: true;
+}): [
+QueryReference<DeepPartial<TData>> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+}): [
+QueryReference<DeepPartial<TData>>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    skip: boolean;
+}): [
+QueryReference<TData> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables>): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): [undefined, UseBackgroundQueryResult<TData, TVariables>];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+})): [
+QueryReference<DeepPartial<TData>> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SkipToken | BackgroundQueryHookOptionsNoInfer<TData, TVariables>): [
+QueryReference<TData> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export type UseBackgroundQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+    fetchMore: FetchMoreFunction<TData, TVariables>;
+    refetch: RefetchFunction<TData, TVariables>;
+};
+
+// @public (undocumented)
+export function useFragment<TData = any, TVars = OperationVariables>(options: UseFragmentOptions<TData, TVars>): UseFragmentResult<TData>;
+
+// @public (undocumented)
+export interface UseFragmentOptions<TData, TVars> extends Omit<Cache_2.DiffOptions<NoInfer<TData>, NoInfer<TVars>>, "id" | "query" | "optimistic" | "previousResult" | "returnPartialData">, Omit<Cache_2.ReadFragmentOptions<TData, TVars>, "id" | "variables" | "returnPartialData"> {
+    // (undocumented)
+    from: StoreObject | Reference | string;
+    // (undocumented)
+    optimistic?: boolean;
+}
+
+// @public (undocumented)
+export type UseFragmentResult<TData> = {
+    data: TData;
+    complete: true;
+    missing?: never;
+} | {
+    data: DeepPartial<TData>;
+    complete: false;
+    missing?: MissingTree;
+};
+
+// @public (undocumented)
+export function useLazyQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: LazyQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): LazyQueryResultTuple<TData, TVariables>;
+
+// @public (undocumented)
+export function useMutation<TData = any, TVariables = OperationVariables, TContext = Context, TCache extends ApolloCache<any> = ApolloCache<any>>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: MutationHookOptions<NoInfer<TData>, NoInfer<TVariables>, TContext, TCache>): MutationTuple<TData, TVariables, TContext, TCache>;
+
+// @public (undocumented)
+export function useQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: QueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): QueryResult<TData, TVariables>;
+
+// Warning: (ae-forgotten-export) The symbol "ReactiveVar" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useReactiveVar<T>(rv: ReactiveVar<T>): T;
+
+// @public (undocumented)
+export function useReadQuery<TData>(queryRef: QueryReference<TData>): {
+    data: TData;
+    networkStatus: NetworkStatus;
+    error: ApolloError | undefined;
+};
+
+// @public (undocumented)
+export function useSubscription<TData = any, TVariables extends OperationVariables = OperationVariables>(subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SubscriptionHookOptions<NoInfer<TData>, NoInfer<TVariables>>): SubscriptionResult<TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData, TVariables extends OperationVariables, TOptions extends Omit<SuspenseQueryHookOptions<TData>, "variables">>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & TOptions): UseSuspenseQueryResult<TOptions["errorPolicy"] extends "ignore" | "all" ? TOptions["returnPartialData"] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions["returnPartialData"] extends true ? TOptions["skip"] extends boolean ? DeepPartial<TData> | undefined : DeepPartial<TData> : TOptions["skip"] extends boolean ? TData | undefined : TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+    errorPolicy: "ignore" | "all";
+}): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    errorPolicy: "ignore" | "all";
+}): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    skip: boolean;
+    returnPartialData: true;
+}): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+}): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    skip: boolean;
+}): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): UseSuspenseQueryResult<TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+})): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SkipToken | SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export interface UseSuspenseQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData;
+    // (undocumented)
+    error: ApolloError | undefined;
+    // (undocumented)
+    fetchMore: FetchMoreFunction<TData, TVariables>;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    refetch: RefetchFunction<TData, TVariables>;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
+}
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/react/hooks/useBackgroundQuery.ts:24:3 - (ae-forgotten-export) The symbol "FetchMoreFunction" needs to be exported by the entry point index.d.ts
+// src/react/hooks/useBackgroundQuery.ts:25:3 - (ae-forgotten-export) The symbol "RefetchFunction" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react_components.md b/.api-reports/api-report-react_components.md
new file mode 100644
index 00000000000..cf07c01004a
--- /dev/null
+++ b/.api-reports/api-report-react_components.md
@@ -0,0 +1,1748 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="react" />
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import * as PropTypes from 'prop-types';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription as Subscription_2 } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+interface BaseMutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, "mutation"> {
+    // Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    ignoreResults?: boolean;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;
+    // (undocumented)
+    onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;
+}
+
+// @public (undocumented)
+interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+interface BaseSubscriptionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    context?: DefaultContext;
+    // Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    onComplete?: () => void;
+    // Warning: (ae-forgotten-export) The symbol "OnDataOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onData?: (options: OnDataOptions<TData>) => any;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    onSubscriptionComplete?: () => void;
+    // Warning: (ae-forgotten-export) The symbol "OnSubscriptionDataOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any;
+    // (undocumented)
+    shouldResubscribe?: boolean | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean);
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+export function Mutation<TData = any, TVariables = OperationVariables>(props: MutationComponentOptions<TData, TVariables>): JSX.Element | null;
+
+// @public (undocumented)
+export namespace Mutation {
+    var // (undocumented)
+    propTypes: PropTypes.InferProps<MutationComponentOptions<any, any, DefaultContext, ApolloCache<any>>>;
+}
+
+// @public (undocumented)
+export interface Mutation<TData, TVariables> {
+    // (undocumented)
+    propTypes: PropTypes.InferProps<MutationComponentOptions<TData, TVariables>>;
+}
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BaseMutationOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface MutationComponentOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFunction" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    children: (mutateFunction: MutationFunction<TData, TVariables, TContext>, result: MutationResult<TData>) => JSX.Element | null;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFunction<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = (options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>;
+
+// @public (undocumented)
+interface MutationFunctionOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationResult<TData = any> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data?: TData | null;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    reset(): void;
+}
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription_2;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription_2;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<ObservableQuery<TData, TVariables>, "startPolling" | "stopPolling" | "subscribeToMore" | "updateQuery" | "refetch" | "reobserve" | "variables" | "fetchMore">;
+
+// @public (undocumented)
+interface OnDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    data: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface OnSubscriptionDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    subscriptionData: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+export function Query<TData = any, TVariables extends OperationVariables = OperationVariables>(props: QueryComponentOptions<TData, TVariables>): JSX.Element | null;
+
+// @public (undocumented)
+export namespace Query {
+    var // (undocumented)
+    propTypes: PropTypes.InferProps<QueryComponentOptions<any, any>>;
+}
+
+// @public (undocumented)
+export interface Query<TData, TVariables extends OperationVariables> {
+    // (undocumented)
+    propTypes: PropTypes.InferProps<QueryComponentOptions<TData, TVariables>>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "QueryFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface QueryComponentOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+    // Warning: (ae-forgotten-export) The symbol "QueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    children: (result: QueryResult<TData, TVariables>) => JSX.Element | null;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BaseQueryOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryFunctionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {
+    // (undocumented)
+    defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
+    // (undocumented)
+    onCompleted?: (data: TData) => void;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    skip?: boolean;
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription_2>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ObservableQueryFields" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryResult<TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData | undefined;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    previousData?: TData;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+export function Subscription<TData = any, TVariables extends OperationVariables = OperationVariables>(props: SubscriptionComponentOptions<TData, TVariables>): JSX.Element | null;
+
+// @public (undocumented)
+export namespace Subscription {
+    var // (undocumented)
+    propTypes: PropTypes.InferProps<SubscriptionComponentOptions<any, any>>;
+}
+
+// @public (undocumented)
+export interface Subscription<TData, TVariables extends OperationVariables> {
+    // (undocumented)
+    propTypes: PropTypes.InferProps<SubscriptionComponentOptions<TData, TVariables>>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BaseSubscriptionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface SubscriptionComponentOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {
+    // (undocumented)
+    children?: null | ((result: SubscriptionResult<TData>) => JSX.Element | null);
+    // (undocumented)
+    subscription: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface SubscriptionResult<TData = any, TVariables = any> {
+    // (undocumented)
+    data?: TData;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react_context.md b/.api-reports/api-report-react_context.md
new file mode 100644
index 00000000000..fe5b3e684cb
--- /dev/null
+++ b/.api-reports/api-report-react_context.md
@@ -0,0 +1,1646 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="react" />
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+export const ApolloConsumer: React_2.FC<ApolloConsumerProps>;
+
+// @public (undocumented)
+export interface ApolloConsumerProps {
+    // Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    children: (client: ApolloClient<object>) => React_2.ReactChild | null;
+}
+
+// @public (undocumented)
+export interface ApolloContextValue {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // Warning: (ae-forgotten-export) The symbol "RenderPromises" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    renderPromises?: RenderPromises;
+}
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+export const ApolloProvider: React_2.FC<ApolloProviderProps<any>>;
+
+// @public (undocumented)
+export interface ApolloProviderProps<TCache> {
+    // (undocumented)
+    children: React_2.ReactNode | React_2.ReactNode[] | null;
+    // (undocumented)
+    client: ApolloClient<TCache>;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+export function getApolloContext(): React_2.Context<ApolloContextValue>;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<ObservableQuery<TData, TVariables>, "startPolling" | "stopPolling" | "subscribeToMore" | "updateQuery" | "refetch" | "reobserve" | "variables" | "fetchMore">;
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+interface QueryData {
+    // (undocumented)
+    fetchData(): Promise<void>;
+    // (undocumented)
+    getOptions(): any;
+}
+
+// Warning: (ae-forgotten-export) The symbol "QueryFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryDataOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+    // Warning: (ae-forgotten-export) The symbol "QueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    children?: (result: QueryResult<TData, TVariables>) => ReactNode;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BaseQueryOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryFunctionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {
+    // (undocumented)
+    defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
+    // (undocumented)
+    onCompleted?: (data: TData) => void;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    skip?: boolean;
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ObservableQueryFields" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryResult<TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData | undefined;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    previousData?: TData;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+class RenderPromises {
+    // (undocumented)
+    addObservableQueryPromise<TData, TVariables extends OperationVariables>(obsQuery: ObservableQuery<TData, TVariables>): ReactNode;
+    // Warning: (ae-forgotten-export) The symbol "QueryData" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addQueryPromise(queryInstance: QueryData, finish?: () => React.ReactNode): React.ReactNode;
+    // (undocumented)
+    consumeAndAwaitPromises(): Promise<any[]>;
+    // Warning: (ae-forgotten-export) The symbol "QueryDataOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getSSRObservable<TData, TVariables extends OperationVariables>(props: QueryDataOptions<TData, TVariables>): ObservableQuery<any, TVariables> | null;
+    // (undocumented)
+    hasPromises(): boolean;
+    // (undocumented)
+    registerSSRObservable<TData, TVariables extends OperationVariables>(observable: ObservableQuery<any, TVariables>): void;
+    // (undocumented)
+    stop(): void;
+}
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+export const resetApolloContext: typeof getApolloContext;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react_hoc.md b/.api-reports/api-report-react_hoc.md
new file mode 100644
index 00000000000..bcfbf8c55c5
--- /dev/null
+++ b/.api-reports/api-report-react_hoc.md
@@ -0,0 +1,1690 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="react" />
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import * as React_2 from 'react';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+interface BaseMutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, "mutation"> {
+    // Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    ignoreResults?: boolean;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;
+    // (undocumented)
+    onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;
+}
+
+// @public (undocumented)
+interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+export type ChildDataProps<TProps = {}, TData = {}, TGraphQLVariables = OperationVariables> = TProps & DataProps<TData, TGraphQLVariables>;
+
+// @public (undocumented)
+export type ChildMutateProps<TProps = {}, TData = {}, TGraphQLVariables = OperationVariables> = TProps & MutateProps<TData, TGraphQLVariables>;
+
+// @public (undocumented)
+export type ChildProps<TProps = {}, TData = {}, TGraphQLVariables = OperationVariables> = TProps & Partial<DataProps<TData, TGraphQLVariables>> & Partial<MutateProps<TData, TGraphQLVariables>>;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+export interface DataProps<TData, TGraphQLVariables = OperationVariables> {
+    // (undocumented)
+    data: DataValue<TData, TGraphQLVariables>;
+}
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export type DataValue<TData, TGraphQLVariables = OperationVariables> = QueryControls<TData, TGraphQLVariables> & Partial<TData>;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {
+    // (undocumented)
+    updateQuery?: (previousQueryResult: TData, options: {
+        fetchMoreResult?: TData;
+        variables?: TVariables;
+    }) => TData;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+export function graphql<TProps extends TGraphQLVariables | {} = {}, TData extends object = {}, TGraphQLVariables extends OperationVariables = {}, TChildProps extends object = Partial<DataProps<TData, TGraphQLVariables>> & Partial<MutateProps<TData, TGraphQLVariables>>>(document: DocumentNode, operationOptions?: OperationOption<TProps, TData, TGraphQLVariables, TChildProps>): (WrappedComponent: React.ComponentType<TProps & TChildProps>) => React.ComponentClass<TProps>;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+export interface MutateProps<TData = any, TGraphQLVariables = OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    mutate: MutationFunction<TData, TGraphQLVariables>;
+    // Warning: (ae-forgotten-export) The symbol "MutationResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    result: MutationResult<TData>;
+}
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFunction<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = (options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>;
+
+// Warning: (ae-forgotten-export) The symbol "BaseMutationOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationFunctionOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationResult<TData = any> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data?: TData | null;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    reset(): void;
+}
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export interface OperationOption<TProps, TData, TGraphQLVariables extends OperationVariables = OperationVariables, TChildProps = ChildProps<TProps, TData, TGraphQLVariables>, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    alias?: string;
+    // (undocumented)
+    name?: string;
+    // Warning: (ae-forgotten-export) The symbol "BaseQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    options?: BaseQueryOptions<TGraphQLVariables> | BaseMutationOptions<TData, TGraphQLVariables, TContext, TCache> | ((props: TProps) => BaseQueryOptions<TGraphQLVariables> | BaseMutationOptions<TData, TGraphQLVariables, TContext, TCache>);
+    // (undocumented)
+    props?: (props: OptionProps<TProps, TData, TGraphQLVariables>, lastProps?: TChildProps | void) => TChildProps;
+    // (undocumented)
+    shouldResubscribe?: (props: TProps, nextProps: TProps) => boolean;
+    // (undocumented)
+    skip?: boolean | ((props: TProps) => boolean);
+    // (undocumented)
+    withRef?: boolean;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+export interface OptionProps<TProps = any, TData = any, TGraphQLVariables = OperationVariables> extends Partial<DataProps<TData, TGraphQLVariables>>, Partial<MutateProps<TData, TGraphQLVariables>> {
+    // (undocumented)
+    ownProps: TProps;
+}
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+export interface QueryControls<TData = any, TGraphQLVariables = OperationVariables> {
+    // (undocumented)
+    error?: ApolloError;
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore: (fetchMoreOptions: FetchMoreQueryOptions<TGraphQLVariables, TData> & FetchMoreOptions<TData, TGraphQLVariables>) => Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: number;
+    // (undocumented)
+    refetch: (variables?: TGraphQLVariables) => Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    startPolling: (pollInterval: number) => void;
+    // (undocumented)
+    stopPolling: () => void;
+    // (undocumented)
+    subscribeToMore: (options: SubscribeToMoreOptions) => () => void;
+    // Warning: (ae-forgotten-export) The symbol "UpdateQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQuery: (mapFn: (previousQueryResult: any, options: UpdateQueryOptions<any>) => any) => void;
+    // (undocumented)
+    variables: TGraphQLVariables;
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UpdateQueryOptions<TVariables> {
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// @public (undocumented)
+export function withApollo<TProps, TResult = any>(WrappedComponent: React_2.ComponentType<WithApolloClient<Omit<TProps, "client">>>, operationOptions?: OperationOption<TProps, TResult>): React_2.ComponentClass<Omit<TProps, "client">>;
+
+// @public (undocumented)
+export type WithApolloClient<P> = P & {
+    client?: ApolloClient<any>;
+};
+
+// @public (undocumented)
+export function withMutation<TProps extends TGraphQLVariables | {} = {}, TData extends Record<string, any> = {}, TGraphQLVariables extends OperationVariables = {}, TChildProps = MutateProps<TData, TGraphQLVariables>, TContext extends Record<string, any> = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>(document: DocumentNode, operationOptions?: OperationOption<TProps, TData, TGraphQLVariables, TChildProps>): (WrappedComponent: React_2.ComponentType<TProps & TChildProps>) => React_2.ComponentClass<TProps>;
+
+// @public (undocumented)
+export function withQuery<TProps extends TGraphQLVariables | Record<string, any> = Record<string, any>, TData extends object = {}, TGraphQLVariables extends object = {}, TChildProps extends object = DataProps<TData, TGraphQLVariables>>(document: DocumentNode, operationOptions?: OperationOption<TProps, TData, TGraphQLVariables, TChildProps>): (WrappedComponent: React_2.ComponentType<TProps & TChildProps>) => React_2.ComponentClass<TProps>;
+
+// @public (undocumented)
+export function withSubscription<TProps extends TGraphQLVariables | {} = {}, TData extends object = {}, TGraphQLVariables extends object = {}, TChildProps extends object = DataProps<TData, TGraphQLVariables>>(document: DocumentNode, operationOptions?: OperationOption<TProps, TData, TGraphQLVariables, TChildProps>): (WrappedComponent: React_2.ComponentType<TProps & TChildProps>) => React_2.ComponentClass<TProps>;
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react_hooks.md b/.api-reports/api-report-react_hooks.md
new file mode 100644
index 00000000000..71597296826
--- /dev/null
+++ b/.api-reports/api-report-react_hooks.md
@@ -0,0 +1,2130 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type BackgroundQueryHookFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
+
+// Warning: (ae-forgotten-export) The symbol "QueryHookOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface BackgroundQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick<QueryHookOptions<TData, TVariables>, "client" | "variables" | "errorPolicy" | "context" | "canonizeResults" | "returnPartialData" | "refetchWritePolicy"> {
+    // Warning: (ae-forgotten-export) The symbol "BackgroundQueryHookFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: BackgroundQueryHookFetchPolicy;
+    // (undocumented)
+    queryKey?: string | number | any[];
+    // (undocumented)
+    skip?: boolean;
+    // Warning: (ae-forgotten-export) The symbol "SuspenseCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    suspenseCache?: SuspenseCache;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BackgroundQueryHookOptions" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "NoInfer" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type BackgroundQueryHookOptionsNoInfer<TData, TVariables extends OperationVariables> = BackgroundQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>;
+
+// @public (undocumented)
+interface BaseMutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, "mutation"> {
+    // Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    ignoreResults?: boolean;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;
+    // (undocumented)
+    onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;
+}
+
+// @public (undocumented)
+interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+interface BaseSubscriptionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    context?: DefaultContext;
+    // Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    onComplete?: () => void;
+    // Warning: (ae-forgotten-export) The symbol "OnDataOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onData?: (options: OnDataOptions<TData>) => any;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    onSubscriptionComplete?: () => void;
+    // Warning: (ae-forgotten-export) The symbol "OnSubscriptionDataOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any;
+    // (undocumented)
+    shouldResubscribe?: boolean | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean);
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+type CacheKey = [
+query: DocumentNode,
+stringifiedVariables: string,
+...queryKey: any[]
+];
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartialPrimitive" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlyMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialSet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlySet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialObject" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartial<T> = T extends DeepPartialPrimitive ? T : T extends Map<infer TKey, infer TValue> ? DeepPartialMap<TKey, TValue> : T extends ReadonlyMap<infer TKey, infer TValue> ? DeepPartialReadonlyMap<TKey, TValue> : T extends Set<infer TItem> ? DeepPartialSet<TItem> : T extends ReadonlySet<infer TItem> ? DeepPartialReadonlySet<TItem> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends ReadonlyArray<infer TItem> ? TItem[] extends T ? readonly TItem[] extends T ? ReadonlyArray<DeepPartial<TItem | undefined>> : Array<DeepPartial<TItem | undefined>> : DeepPartialObject<T> : DeepPartialObject<T> : unknown;
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartial" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartialMap<TKey, TValue> = {} & Map<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialObject<T extends object> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Primitive" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartialPrimitive = Primitive | Date | RegExp;
+
+// @public (undocumented)
+type DeepPartialReadonlyMap<TKey, TValue> = {} & ReadonlyMap<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialReadonlySet<T> = {} & ReadonlySet<DeepPartial<T>>;
+
+// @public (undocumented)
+type DeepPartialSet<T> = {} & Set<DeepPartial<T>>;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchMoreFunction<TData, TVariables extends OperationVariables> = (fetchMoreOptions: FetchMoreQueryOptions<TVariables, TData> & {
+    updateQuery?: (previousQueryResult: TData, options: {
+        fetchMoreResult: TData;
+        variables: TVariables;
+    }) => TData;
+}) => Promise<ApolloQueryResult<TData>>;
+
+// @public (undocumented)
+type FetchMoreOptions<TData> = Parameters<ObservableQuery<TData>["fetchMore"]>[0];
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+class InternalQueryReference<TData = unknown> {
+    // Warning: (ae-forgotten-export) The symbol "InternalQueryReferenceOptions" needs to be exported by the entry point index.d.ts
+    constructor(observable: ObservableQuery<TData>, options: InternalQueryReferenceOptions);
+    // (undocumented)
+    applyOptions(watchQueryOptions: ObservedOptions): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "ObservedOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    didChangeOptions(watchQueryOptions: ObservedOptions): boolean;
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore(options: FetchMoreOptions<TData>): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "CacheKey" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly key: CacheKey;
+    // Warning: (ae-forgotten-export) The symbol "Listener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listen(listener: Listener<TData>): () => void;
+    // (undocumented)
+    readonly observable: ObservableQuery<TData>;
+    // (undocumented)
+    promise: Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    promiseCache?: Map<CacheKey, Promise<ApolloQueryResult<TData>>>;
+    // (undocumented)
+    refetch(variables: OperationVariables | undefined): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    result: ApolloQueryResult<TData>;
+    // (undocumented)
+    retain(): () => void;
+    // (undocumented)
+    get watchQueryOptions(): WatchQueryOptions<OperationVariables, TData>;
+}
+
+// @public (undocumented)
+interface InternalQueryReferenceOptions {
+    // (undocumented)
+    autoDisposeTimeoutMs?: number;
+    // (undocumented)
+    key: CacheKey;
+    // (undocumented)
+    onDispose?: () => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// Warning: (ae-forgotten-export) The symbol "LazyQueryHookExecOptions" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "QueryResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type LazyQueryExecFunction<TData, TVariables extends OperationVariables> = (options?: Partial<LazyQueryHookExecOptions<TData, TVariables>>) => Promise<QueryResult<TData, TVariables>>;
+
+// Warning: (ae-forgotten-export) The symbol "LazyQueryHookOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface LazyQueryHookExecOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends LazyQueryHookOptions<TData, TVariables> {
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+interface LazyQueryHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends Omit<QueryHookOptions<TData, TVariables>, "skip"> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "LazyQueryExecFunction" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type LazyQueryResultTuple<TData, TVariables extends OperationVariables> = [LazyQueryExecFunction<TData, TVariables>, QueryResult<TData, TVariables>];
+
+// @public (undocumented)
+type Listener<TData> = (promise: Promise<ApolloQueryResult<TData>>) => void;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "BaseMutationOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationFunctionOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+interface MutationHookOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationResult<TData = any> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data?: TData | null;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    reset(): void;
+}
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "MutationFunctionOptions" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "MutationResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationTuple<TData, TVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = [
+(options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>,
+MutationResult<TData>
+];
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+type NoInfer<T> = [T][T extends any ? 0 : never];
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<ObservableQuery<TData, TVariables>, "startPolling" | "stopPolling" | "subscribeToMore" | "updateQuery" | "refetch" | "reobserve" | "variables" | "fetchMore">;
+
+// @public (undocumented)
+const OBSERVED_CHANGED_OPTIONS: readonly ["canonizeResults", "context", "errorPolicy", "fetchPolicy", "refetchWritePolicy", "returnPartialData"];
+
+// Warning: (ae-forgotten-export) The symbol "OBSERVED_CHANGED_OPTIONS" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ObservedOptions = Pick<WatchQueryOptions, (typeof OBSERVED_CHANGED_OPTIONS)[number]>;
+
+// @public (undocumented)
+interface OnDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    data: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface OnSubscriptionDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    subscriptionData: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+
+// @public (undocumented)
+const QUERY_REFERENCE_SYMBOL: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "BaseQueryOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryFunctionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {
+    // (undocumented)
+    defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
+    // (undocumented)
+    onCompleted?: (data: TData) => void;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    skip?: boolean;
+}
+
+// Warning: (ae-forgotten-export) The symbol "QueryFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface QueryReference<TData = unknown> {
+    // Warning: (ae-forgotten-export) The symbol "InternalQueryReference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    [QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ObservableQueryFields" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryResult<TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData | undefined;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    previousData?: TData;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+type ReactiveListener<T> = (value: T) => any;
+
+// @public (undocumented)
+interface ReactiveVar<T> {
+    // (undocumented)
+    (newValue?: T): T;
+    // (undocumented)
+    attachCache(cache: ApolloCache<any>): this;
+    // (undocumented)
+    forgetCache(cache: ApolloCache<any>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onNextChange(listener: ReactiveListener<T>): () => void;
+}
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchFunction<TData, TVariables extends OperationVariables> = ObservableQueryFields<TData, TVariables>["refetch"];
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export type SkipToken = typeof skipToken;
+
+// @public (undocumented)
+export const skipToken: unique symbol;
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+type SubscribeToMoreFunction<TData, TVariables extends OperationVariables> = ObservableQueryFields<TData, TVariables>["subscribeToMore"];
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// Warning: (ae-forgotten-export) The symbol "BaseSubscriptionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface SubscriptionHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {
+}
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface SubscriptionResult<TData = any, TVariables = any> {
+    // (undocumented)
+    data?: TData;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SuspenseCache_2" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+class SuspenseCache extends SuspenseCache_2 {
+    constructor();
+}
+
+// @public (undocumented)
+class SuspenseCache_2 {
+    // Warning: (ae-forgotten-export) The symbol "SuspenseCacheOptions" needs to be exported by the entry point index.d.ts
+    constructor(options?: SuspenseCacheOptions);
+    // (undocumented)
+    getQueryRef<TData = any>(cacheKey: CacheKey, createObservable: () => ObservableQuery<TData>): InternalQueryReference<TData>;
+}
+
+// @public (undocumented)
+interface SuspenseCacheOptions {
+    // (undocumented)
+    autoDisposeTimeoutMs?: number;
+}
+
+// @public (undocumented)
+type SuspenseQueryHookFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
+
+// @public (undocumented)
+interface SuspenseQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick<QueryHookOptions<TData, TVariables>, "client" | "variables" | "errorPolicy" | "context" | "canonizeResults" | "returnPartialData" | "refetchWritePolicy"> {
+    // Warning: (ae-forgotten-export) The symbol "SuspenseQueryHookFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: SuspenseQueryHookFetchPolicy;
+    // (undocumented)
+    queryKey?: string | number | any[];
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    suspenseCache?: SuspenseCache;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export function useApolloClient(override?: ApolloClient<object>): ApolloClient<object>;
+
+// Warning: (ae-forgotten-export) The symbol "BackgroundQueryHookOptionsNoInfer" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "QueryReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useBackgroundQuery<TData, TVariables extends OperationVariables, TOptions extends Omit<BackgroundQueryHookOptions<TData>, "variables">>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & TOptions): [
+(QueryReference<TOptions["errorPolicy"] extends "ignore" | "all" ? TOptions["returnPartialData"] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions["returnPartialData"] extends true ? DeepPartial<TData> : TData> | (TOptions["skip"] extends boolean ? undefined : never)),
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+    errorPolicy: "ignore" | "all";
+}): [
+QueryReference<DeepPartial<TData> | undefined>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    errorPolicy: "ignore" | "all";
+}): [
+QueryReference<TData | undefined>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    skip: boolean;
+    returnPartialData: true;
+}): [
+QueryReference<DeepPartial<TData>> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+}): [
+QueryReference<DeepPartial<TData>>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    skip: boolean;
+}): [
+QueryReference<TData> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables>): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): [undefined, UseBackgroundQueryResult<TData, TVariables>];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+})): [
+QueryReference<DeepPartial<TData>> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SkipToken | BackgroundQueryHookOptionsNoInfer<TData, TVariables>): [
+QueryReference<TData> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export type UseBackgroundQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+    fetchMore: FetchMoreFunction<TData, TVariables>;
+    refetch: RefetchFunction<TData, TVariables>;
+};
+
+// @public (undocumented)
+export function useFragment<TData = any, TVars = OperationVariables>(options: UseFragmentOptions<TData, TVars>): UseFragmentResult<TData>;
+
+// @public (undocumented)
+export interface UseFragmentOptions<TData, TVars> extends Omit<Cache_2.DiffOptions<NoInfer<TData>, NoInfer<TVars>>, "id" | "query" | "optimistic" | "previousResult" | "returnPartialData">, Omit<Cache_2.ReadFragmentOptions<TData, TVars>, "id" | "variables" | "returnPartialData"> {
+    // (undocumented)
+    from: StoreObject | Reference | string;
+    // (undocumented)
+    optimistic?: boolean;
+}
+
+// @public (undocumented)
+export type UseFragmentResult<TData> = {
+    data: TData;
+    complete: true;
+    missing?: never;
+} | {
+    data: DeepPartial<TData>;
+    complete: false;
+    missing?: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "LazyQueryResultTuple" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useLazyQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: LazyQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): LazyQueryResultTuple<TData, TVariables>;
+
+// Warning: (ae-forgotten-export) The symbol "MutationHookOptions" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "MutationTuple" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useMutation<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: MutationHookOptions<NoInfer<TData>, NoInfer<TVariables>, TContext, TCache>): MutationTuple<TData, TVariables, TContext, TCache>;
+
+// @public (undocumented)
+export function useQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: QueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): QueryResult<TData, TVariables>;
+
+// Warning: (ae-forgotten-export) The symbol "ReactiveVar" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useReactiveVar<T>(rv: ReactiveVar<T>): T;
+
+// @public (undocumented)
+export function useReadQuery<TData>(queryRef: QueryReference<TData>): {
+    data: TData;
+    networkStatus: NetworkStatus;
+    error: ApolloError | undefined;
+};
+
+// Warning: (ae-forgotten-export) The symbol "SubscriptionHookOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useSubscription<TData = any, TVariables extends OperationVariables = OperationVariables>(subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SubscriptionHookOptions<NoInfer<TData>, NoInfer<TVariables>>): SubscriptionResult<TData, TVariables>;
+
+// Warning: (ae-forgotten-export) The symbol "SuspenseQueryHookOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useSuspenseQuery<TData, TVariables extends OperationVariables, TOptions extends Omit<SuspenseQueryHookOptions<TData>, "variables">>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & TOptions): UseSuspenseQueryResult<TOptions["errorPolicy"] extends "ignore" | "all" ? TOptions["returnPartialData"] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions["returnPartialData"] extends true ? TOptions["skip"] extends boolean ? DeepPartial<TData> | undefined : DeepPartial<TData> : TOptions["skip"] extends boolean ? TData | undefined : TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+    errorPolicy: "ignore" | "all";
+}): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    errorPolicy: "ignore" | "all";
+}): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    skip: boolean;
+    returnPartialData: true;
+}): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+}): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    skip: boolean;
+}): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): UseSuspenseQueryResult<TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+})): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SkipToken | SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export interface UseSuspenseQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData;
+    // (undocumented)
+    error: ApolloError | undefined;
+    // (undocumented)
+    fetchMore: FetchMoreFunction<TData, TVariables>;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    refetch: RefetchFunction<TData, TVariables>;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
+}
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/react/hooks/useBackgroundQuery.ts:24:3 - (ae-forgotten-export) The symbol "FetchMoreFunction" needs to be exported by the entry point index.d.ts
+// src/react/hooks/useBackgroundQuery.ts:25:3 - (ae-forgotten-export) The symbol "RefetchFunction" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react_parser.md b/.api-reports/api-report-react_parser.md
new file mode 100644
index 00000000000..96d961506af
--- /dev/null
+++ b/.api-reports/api-report-react_parser.md
@@ -0,0 +1,42 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DocumentNode } from 'graphql';
+import type { VariableDefinitionNode } from 'graphql';
+
+// @public (undocumented)
+enum DocumentType_2 {
+    // (undocumented)
+    Mutation = 1,
+    // (undocumented)
+    Query = 0,
+    // (undocumented)
+    Subscription = 2
+}
+export { DocumentType_2 as DocumentType }
+
+// @public (undocumented)
+export interface IDocumentDefinition {
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    type: DocumentType_2;
+    // (undocumented)
+    variables: ReadonlyArray<VariableDefinitionNode>;
+}
+
+// @public (undocumented)
+export function operationName(type: DocumentType_2): string;
+
+// @public (undocumented)
+export function parser(document: DocumentNode): IDocumentDefinition;
+
+// @public (undocumented)
+export function verifyDocumentType(document: DocumentNode, type: DocumentType_2): void;
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-react_ssr.md b/.api-reports/api-report-react_ssr.md
new file mode 100644
index 00000000000..4e617cff33e
--- /dev/null
+++ b/.api-reports/api-report-react_ssr.md
@@ -0,0 +1,1633 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="react" />
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import * as React_2 from 'react';
+import type { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+export function getDataFromTree(tree: React_2.ReactNode, context?: {
+    [key: string]: any;
+}): Promise<string>;
+
+// Warning: (ae-forgotten-export) The symbol "GetMarkupFromTreeOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function getMarkupFromTree({ tree, context, renderFunction, }: GetMarkupFromTreeOptions): Promise<string>;
+
+// @public (undocumented)
+type GetMarkupFromTreeOptions = {
+    tree: React_2.ReactNode;
+    context?: {
+        [key: string]: any;
+    };
+    renderFunction?: (tree: React_2.ReactElement<any>) => string | PromiseLike<string>;
+};
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<ObservableQuery<TData, TVariables>, "startPolling" | "stopPolling" | "subscribeToMore" | "updateQuery" | "refetch" | "reobserve" | "variables" | "fetchMore">;
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+interface QueryData {
+    // (undocumented)
+    fetchData(): Promise<void>;
+    // (undocumented)
+    getOptions(): any;
+}
+
+// Warning: (ae-forgotten-export) The symbol "QueryFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryDataOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+    // Warning: (ae-forgotten-export) The symbol "QueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    children?: (result: QueryResult<TData, TVariables>) => ReactNode;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BaseQueryOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryFunctionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {
+    // (undocumented)
+    defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
+    // (undocumented)
+    onCompleted?: (data: TData) => void;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    skip?: boolean;
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ObservableQueryFields" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface QueryResult<TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData | undefined;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    previousData?: TData;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+export class RenderPromises {
+    // (undocumented)
+    addObservableQueryPromise<TData, TVariables extends OperationVariables>(obsQuery: ObservableQuery<TData, TVariables>): ReactNode;
+    // Warning: (ae-forgotten-export) The symbol "QueryData" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addQueryPromise(queryInstance: QueryData, finish?: () => React.ReactNode): React.ReactNode;
+    // (undocumented)
+    consumeAndAwaitPromises(): Promise<any[]>;
+    // Warning: (ae-forgotten-export) The symbol "QueryDataOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getSSRObservable<TData, TVariables extends OperationVariables>(props: QueryDataOptions<TData, TVariables>): ObservableQuery<any, TVariables> | null;
+    // (undocumented)
+    hasPromises(): boolean;
+    // (undocumented)
+    registerSSRObservable<TData, TVariables extends OperationVariables>(observable: ObservableQuery<any, TVariables>): void;
+    // (undocumented)
+    stop(): void;
+}
+
+// @public (undocumented)
+export function renderToStringWithData(component: ReactElement<any>): Promise<string>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-testing.md b/.api-reports/api-report-testing.md
new file mode 100644
index 00000000000..70b9d593258
--- /dev/null
+++ b/.api-reports/api-report-testing.md
@@ -0,0 +1,1681 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import * as React_2 from 'react';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "NormalizedCacheObject" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function createMockClient<TData>(data: TData, query: DocumentNode, variables?: {}): ApolloClient<NormalizedCacheObject>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+export const itAsync: ((message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number | undefined) => any) & {
+    only: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+    skip: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+    todo: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+};
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// @public (undocumented)
+interface MockApolloLink extends ApolloLink {
+    // (undocumented)
+    operation?: Operation;
+}
+
+// Warning: (ae-forgotten-export) The symbol "MockedProviderState" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class MockedProvider extends React_2.Component<MockedProviderProps, MockedProviderState> {
+    constructor(props: MockedProviderProps);
+    // (undocumented)
+    componentWillUnmount(): void;
+    // (undocumented)
+    static defaultProps: MockedProviderProps;
+    // (undocumented)
+    render(): React_2.JSX.Element | null;
+}
+
+// @public (undocumented)
+export interface MockedProviderProps<TSerializedCache = {}> {
+    // (undocumented)
+    addTypename?: boolean;
+    // (undocumented)
+    cache?: ApolloCache<TSerializedCache>;
+    // (undocumented)
+    childProps?: object;
+    // (undocumented)
+    children?: any;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions?: DefaultOptions;
+    // (undocumented)
+    link?: ApolloLink;
+    // (undocumented)
+    mocks?: ReadonlyArray<MockedResponse>;
+    // (undocumented)
+    resolvers?: Resolvers;
+    // (undocumented)
+    showWarnings?: boolean;
+}
+
+// @public (undocumented)
+interface MockedProviderState {
+    // (undocumented)
+    client: ApolloClient<any>;
+}
+
+// @public (undocumented)
+export interface MockedResponse<TData = Record<string, any>, TVariables = Record<string, any>> {
+    // (undocumented)
+    delay?: number;
+    // (undocumented)
+    error?: Error;
+    // (undocumented)
+    newData?: ResultFunction<FetchResult>;
+    // (undocumented)
+    request: GraphQLRequest<TVariables>;
+    // (undocumented)
+    result?: FetchResult<TData> | ResultFunction<FetchResult<TData>>;
+}
+
+// @public (undocumented)
+interface MockedSubscriptionResult {
+    // (undocumented)
+    delay?: number;
+    // (undocumented)
+    error?: Error;
+    // (undocumented)
+    result?: FetchResult;
+}
+
+// @public (undocumented)
+export class MockLink extends ApolloLink {
+    constructor(mockedResponses: ReadonlyArray<MockedResponse>, addTypename?: Boolean, options?: MockLinkOptions);
+    // (undocumented)
+    addMockedResponse(mockedResponse: MockedResponse): void;
+    // (undocumented)
+    addTypename: Boolean;
+    // (undocumented)
+    operation: Operation;
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult> | null;
+    // (undocumented)
+    showWarnings: boolean;
+}
+
+// @public (undocumented)
+export interface MockLinkOptions {
+    // (undocumented)
+    showWarnings?: boolean;
+}
+
+// @public (undocumented)
+export function mockObservableLink(): MockSubscriptionLink;
+
+// Warning: (ae-forgotten-export) The symbol "MockApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function mockSingleLink(...mockedResponses: Array<any>): MockApolloLink;
+
+// @public (undocumented)
+export class MockSubscriptionLink extends ApolloLink {
+    constructor();
+    // (undocumented)
+    onSetup(listener: any): void;
+    // (undocumented)
+    onUnsubscribe(listener: any): void;
+    // (undocumented)
+    operation: Operation;
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult>;
+    // (undocumented)
+    setups: any[];
+    // (undocumented)
+    simulateComplete(): void;
+    // Warning: (ae-forgotten-export) The symbol "MockedSubscriptionResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    simulateResult(result: MockedSubscriptionResult, complete?: boolean): void;
+    // (undocumented)
+    unsubscribers: any[];
+}
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+interface NormalizedCacheObject {
+    // (undocumented)
+    [dataId: string]: StoreObject | undefined;
+    // (undocumented)
+    __META?: {
+        extraRootIds: string[];
+    };
+}
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+export type ResultFunction<T> = () => T;
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+export function subscribeAndCount<TResult>(reject: (reason: any) => any, observable: Observable<TResult>, cb: (handleCount: number, result: TResult) => any): Subscription;
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export function tick(): Promise<void>;
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export function wait(ms: number): Promise<void>;
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// @public (undocumented)
+export function withErrorSpy<TArgs extends any[], TResult>(it: (...args: TArgs) => TResult, ...args: TArgs): TResult;
+
+// @public (undocumented)
+export function withLogSpy<TArgs extends any[], TResult>(it: (...args: TArgs) => TResult, ...args: TArgs): TResult;
+
+// @public (undocumented)
+export function withWarningSpy<TArgs extends any[], TResult>(it: (...args: TArgs) => TResult, ...args: TArgs): TResult;
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-testing_core.md b/.api-reports/api-report-testing_core.md
new file mode 100644
index 00000000000..2dc55496b8d
--- /dev/null
+++ b/.api-reports/api-report-testing_core.md
@@ -0,0 +1,1639 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ASTNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import type { Subscriber } from 'zen-observable-ts';
+import type { Subscription } from 'zen-observable-ts';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // Warning: (ae-forgotten-export) The symbol "StoreObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "Reference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransform" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// Warning: (ae-forgotten-export) The symbol "StoreValue" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// Warning: (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "NormalizedCacheObject" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function createMockClient<TData>(data: TData, query: DocumentNode, variables?: {}): ApolloClient<NormalizedCacheObject>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+export const itAsync: ((message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number | undefined) => any) & {
+    only: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+    skip: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+    todo: (message: string, callback: (resolve: (result?: any) => void, reject: (reason?: any) => void) => any, timeout?: number) => void;
+};
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// @public (undocumented)
+interface MockApolloLink extends ApolloLink {
+    // (undocumented)
+    operation?: Operation;
+}
+
+// @public (undocumented)
+export interface MockedResponse<TData = Record<string, any>, TVariables = Record<string, any>> {
+    // (undocumented)
+    delay?: number;
+    // (undocumented)
+    error?: Error;
+    // (undocumented)
+    newData?: ResultFunction<FetchResult>;
+    // (undocumented)
+    request: GraphQLRequest<TVariables>;
+    // (undocumented)
+    result?: FetchResult<TData> | ResultFunction<FetchResult<TData>>;
+}
+
+// @public (undocumented)
+interface MockedSubscriptionResult {
+    // (undocumented)
+    delay?: number;
+    // (undocumented)
+    error?: Error;
+    // (undocumented)
+    result?: FetchResult;
+}
+
+// @public (undocumented)
+export class MockLink extends ApolloLink {
+    constructor(mockedResponses: ReadonlyArray<MockedResponse>, addTypename?: Boolean, options?: MockLinkOptions);
+    // (undocumented)
+    addMockedResponse(mockedResponse: MockedResponse): void;
+    // (undocumented)
+    addTypename: Boolean;
+    // (undocumented)
+    operation: Operation;
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult> | null;
+    // (undocumented)
+    showWarnings: boolean;
+}
+
+// @public (undocumented)
+export interface MockLinkOptions {
+    // (undocumented)
+    showWarnings?: boolean;
+}
+
+// @public (undocumented)
+export function mockObservableLink(): MockSubscriptionLink;
+
+// Warning: (ae-forgotten-export) The symbol "MockApolloLink" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function mockSingleLink(...mockedResponses: Array<any>): MockApolloLink;
+
+// @public (undocumented)
+export class MockSubscriptionLink extends ApolloLink {
+    constructor();
+    // (undocumented)
+    onSetup(listener: any): void;
+    // (undocumented)
+    onUnsubscribe(listener: any): void;
+    // (undocumented)
+    operation: Operation;
+    // (undocumented)
+    request(operation: Operation): Observable<FetchResult>;
+    // (undocumented)
+    setups: any[];
+    // (undocumented)
+    simulateComplete(): void;
+    // Warning: (ae-forgotten-export) The symbol "MockedSubscriptionResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    simulateResult(result: MockedSubscriptionResult, complete?: boolean): void;
+    // (undocumented)
+    unsubscribers: any[];
+}
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+interface NormalizedCacheObject {
+    // (undocumented)
+    [dataId: string]: StoreObject | undefined;
+    // (undocumented)
+    __META?: {
+        extraRootIds: string[];
+    };
+}
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): Subscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<Subscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+export type ResultFunction<T> = () => T;
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+export function subscribeAndCount<TResult>(reject: (reason: any) => any, observable: Observable<TResult>, cb: (handleCount: number, result: TResult) => any): Subscription;
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export function tick(): Promise<void>;
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export function wait(ms: number): Promise<void>;
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// @public (undocumented)
+export function withErrorSpy<TArgs extends any[], TResult>(it: (...args: TArgs) => TResult, ...args: TArgs): TResult;
+
+// @public (undocumented)
+export function withLogSpy<TArgs extends any[], TResult>(it: (...args: TArgs) => TResult, ...args: TArgs): TResult;
+
+// @public (undocumented)
+export function withWarningSpy<TArgs extends any[], TResult>(it: (...args: TArgs) => TResult, ...args: TArgs): TResult;
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:95:3 - (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:96:3 - (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:97:3 - (ae-forgotten-export) The symbol "isReference" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:98:3 - (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+// src/cache/core/types/common.ts:99:3 - (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:46:5 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/DocumentTransform.ts:122:7 - (ae-forgotten-export) The symbol "DocumentTransformCacheKey" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-utilities.md b/.api-reports/api-report-utilities.md
new file mode 100644
index 00000000000..410b9ded70b
--- /dev/null
+++ b/.api-reports/api-report-utilities.md
@@ -0,0 +1,2526 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { ArgumentNode } from 'graphql';
+import type { ASTNode } from 'graphql';
+import type { DirectiveNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import type { FragmentSpreadNode } from 'graphql';
+import { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import type { InlineFragmentNode } from 'graphql';
+import type { NameNode } from 'graphql';
+import { Observable } from 'zen-observable-ts';
+import type { Subscription as ObservableSubscription } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import type { OperationDefinitionNode } from 'graphql';
+import { print as print_3 } from 'graphql';
+import type { SelectionNode } from 'graphql';
+import type { SelectionSetNode } from 'graphql';
+import type { Subscriber } from 'zen-observable-ts';
+import { Trie } from '@wry/trie';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { ValueNode } from 'graphql';
+import type { VariableDefinitionNode } from 'graphql';
+import type { VariableNode } from 'graphql';
+
+// @public (undocumented)
+export const addTypenameToDocument: (<TNode extends ASTNode>(doc: TNode) => TNode) & {
+    added(field: FieldNode): boolean;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Transaction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // Warning: (ae-forgotten-export) The symbol "GraphQLRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // Warning: (ae-forgotten-export) The symbol "Resolvers" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // Warning: (ae-forgotten-export) The symbol "ApolloCache" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // Warning: (ae-forgotten-export) The symbol "ApolloLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    link: ApolloLink;
+    // Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "MutationOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // Warning: (ae-forgotten-export) The symbol "QueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ApolloQueryResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RefetchQueriesResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMatcher" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscriptionOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // Warning: (ae-forgotten-export) The symbol "ApolloClientOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // Warning: (ae-forgotten-export) The symbol "OperationVariables" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ObservableQuery" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// @public (undocumented)
+class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // Warning: (ae-forgotten-export) The symbol "RequestHandler" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // Warning: (ae-forgotten-export) The symbol "NextLink" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+interface ApolloPayloadResult<TData = Record<string, any>, TExtensions = Record<string, any>> {
+    // (undocumented)
+    errors?: ReadonlyArray<Error | string>;
+    // Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    payload: SingleExecutionResult | ExecutionPatchResult | null;
+}
+
+// @public (undocumented)
+type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+type ApolloReducerConfig = {
+    dataIdFromObject?: KeyFieldsFunction;
+    addTypename?: boolean;
+};
+
+// @public (undocumented)
+export function argumentsObjectFromField(field: FieldNode | DirectiveNode, variables?: Record<string, any>): Object | null;
+
+// @public (undocumented)
+export function asyncMap<V, R>(observable: Observable<V>, mapFn: (value: V) => R | PromiseLike<R>, catchFn?: (error: any) => R | PromiseLike<R>): Observable<R>;
+
+// Warning: (ae-forgotten-export) The symbol "InMemoryCache" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type BroadcastOptions = Pick<Cache_2.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
+
+// @public (undocumented)
+export function buildQueryFromSelectionSet(document: DocumentNode): DocumentNode;
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // Warning: (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+
+// @public (undocumented)
+class CacheGroup {
+    constructor(caching: boolean, parent?: CacheGroup | null);
+    // (undocumented)
+    readonly caching: boolean;
+    // (undocumented)
+    depend(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    dirty(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    keyMaker: Trie<object>;
+    // (undocumented)
+    resetCaching(): void;
+}
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+export const canUseAsyncIteratorSymbol: false | typeof Symbol.asyncIterator;
+
+// @public (undocumented)
+export const canUseDOM: boolean;
+
+// @public (undocumented)
+export const canUseLayoutEffect: boolean;
+
+// @public (undocumented)
+export const canUseSymbol: boolean;
+
+// @public (undocumented)
+export const canUseWeakMap: boolean;
+
+// @public (undocumented)
+export const canUseWeakSet: boolean;
+
+// @public (undocumented)
+export function checkDocument(doc: DocumentNode): DocumentNode;
+
+// @public (undocumented)
+export function cloneDeep<T>(value: T): T;
+
+// @public (undocumented)
+export function compact<TArgs extends any[]>(...objects: TArgs): TupleToIntersection<TArgs>;
+
+// @public (undocumented)
+export class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type ConcastSourcesArray<T> = Array<Source<T>>;
+
+// @public (undocumented)
+export type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// Warning: (ae-forgotten-export) The symbol "KeyArgs" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "FieldPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function concatPagination<T = Reference>(keyArgs?: KeyArgs): FieldPolicy<T[]>;
+
+// @public (undocumented)
+export function createFragmentMap(fragments?: FragmentDefinitionNode[]): FragmentMap;
+
+// Warning: (ae-forgotten-export) The symbol "FulfilledPromise" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function createFulfilledPromise<TValue>(value: TValue): FulfilledPromise<TValue>;
+
+// Warning: (ae-forgotten-export) The symbol "RejectedPromise" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function createRejectedPromise<TValue = unknown>(reason: unknown): RejectedPromise<TValue>;
+
+// @public (undocumented)
+namespace DataProxy {
+    // (undocumented)
+    type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // Warning: (ae-forgotten-export) The symbol "DataProxy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export class DeepMerger<TContextArgs extends any[]> {
+    constructor(reconciler?: ReconcilerFunction<TContextArgs>);
+    // (undocumented)
+    isObject: typeof isNonNullObject;
+    // (undocumented)
+    merge(target: any, source: any, ...context: TContextArgs): any;
+    // (undocumented)
+    shallowCopyForMerge<T>(value: T): T;
+}
+
+// Warning: (ae-forgotten-export) The symbol "DeepOmitPrimitive" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepOmitArray" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type DeepOmit<T, K> = T extends DeepOmitPrimitive ? T : {
+    [P in Exclude<keyof T, K>]: T[P] extends infer TP ? TP extends DeepOmitPrimitive ? TP : TP extends any[] ? DeepOmitArray<TP, K> : DeepOmit<TP, K> : never;
+};
+
+// @public (undocumented)
+type DeepOmitArray<T extends any[], K> = {
+    [P in keyof T]: DeepOmit<T[P], K>;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Primitive" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepOmitPrimitive = Primitive | Function;
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartialPrimitive" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlyMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialSet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlySet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialObject" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type DeepPartial<T> = T extends DeepPartialPrimitive ? T : T extends Map<infer TKey, infer TValue> ? DeepPartialMap<TKey, TValue> : T extends ReadonlyMap<infer TKey, infer TValue> ? DeepPartialReadonlyMap<TKey, TValue> : T extends Set<infer TItem> ? DeepPartialSet<TItem> : T extends ReadonlySet<infer TItem> ? DeepPartialReadonlySet<TItem> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends ReadonlyArray<infer TItem> ? TItem[] extends T ? readonly TItem[] extends T ? ReadonlyArray<DeepPartial<TItem | undefined>> : Array<DeepPartial<TItem | undefined>> : DeepPartialObject<T> : DeepPartialObject<T> : unknown;
+
+// @public (undocumented)
+type DeepPartialMap<TKey, TValue> = {} & Map<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialObject<T extends object> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+// @public (undocumented)
+type DeepPartialPrimitive = Primitive | Date | RegExp;
+
+// @public (undocumented)
+type DeepPartialReadonlyMap<TKey, TValue> = {} & ReadonlyMap<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialReadonlySet<T> = {} & ReadonlySet<DeepPartial<T>>;
+
+// @public (undocumented)
+type DeepPartialSet<T> = {} & Set<DeepPartial<T>>;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+
+// @public (undocumented)
+interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+export const DEV: boolean;
+
+// @public (undocumented)
+export type DirectiveInfo = {
+    [fieldName: string]: {
+        [argName: string]: any;
+    };
+};
+
+// @public (undocumented)
+export type Directives = {
+    [directiveName: string]: {
+        [argName: string]: any;
+    };
+};
+
+// @public (undocumented)
+export class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+export type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "NormalizedCache" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+abstract class EntityStore implements NormalizedCache {
+    constructor(policies: Policies, group: CacheGroup);
+    // Warning: (ae-forgotten-export) The symbol "Layer" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // Warning: (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // Warning: (ae-forgotten-export) The symbol "NormalizedCacheObject" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected data: NormalizedCacheObject;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string, args?: Record<string, any>): boolean;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions, limit: EntityStore): boolean;
+    // (undocumented)
+    extract(): NormalizedCacheObject;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
+    // (undocumented)
+    getRootIdSet(ids?: Set<string>): Set<string>;
+    // Warning: (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // Warning: (ae-forgotten-export) The symbol "CacheGroup" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    protected lookup(dataId: string, dependOnExistence?: boolean): StoreObject | undefined;
+    // (undocumented)
+    makeCacheKey(...args: any[]): object;
+    // (undocumented)
+    merge(older: string | StoreObject, newer: StoreObject | string): void;
+    // (undocumented)
+    modify(dataId: string, fields: Modifier<any> | Modifiers<Record<string, any>>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Policies" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    abstract removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject | null): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // Warning: (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+namespace EntityStore {
+    // (undocumented)
+    class Root extends EntityStore {
+        constructor({ policies, resultCaching, seed, }: {
+            policies: Policies;
+            resultCaching?: boolean;
+            seed?: NormalizedCacheObject;
+        });
+        // (undocumented)
+        addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+        // (undocumented)
+        getStorage(): StorageType;
+        // (undocumented)
+        removeLayer(): Root;
+        // (undocumented)
+        readonly storageTrie: Trie<StorageType>;
+        // Warning: (ae-forgotten-export) The symbol "Stump" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        readonly stump: Stump;
+    }
+}
+
+// @public (undocumented)
+type ErrorPolicy = "none" | "ignore" | "all";
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// @public (undocumented)
+type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface FieldFunctionOptions<TArgs = Record<string, any>, TVars = Record<string, any>> {
+    // (undocumented)
+    args: TArgs | null;
+    // (undocumented)
+    cache: InMemoryCache;
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    field: FieldNode | null;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    isReference: typeof isReference;
+    // Warning: (ae-forgotten-export) The symbol "MergeObjectsFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    mergeObjects: MergeObjectsFunction;
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField: ReadFieldFunction;
+    // (undocumented)
+    storage: StorageType;
+    // (undocumented)
+    storeFieldName: string;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+    // (undocumented)
+    variables?: TVars;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FieldFunctionOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
+
+// @public (undocumented)
+type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
+    keyArgs?: KeySpecifier | KeyArgsFunction | false;
+    read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
+    merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
+};
+
+// @public (undocumented)
+type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "EntityStore" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FieldValueGetter = EntityStore["getFieldValue"];
+
+// @public (undocumented)
+export function fixObservableSubclass<S extends new (...args: any[]) => Observable<any>>(subclass: S): S;
+
+// Warning: (ae-forgotten-export) The symbol "WriteContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FlavorableWriteContext = Pick<WriteContext, "clientOnly" | "deferred" | "flavors">;
+
+// @public (undocumented)
+export interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+export type FragmentMapFunction = (fragmentName: string) => FragmentDefinitionNode | null;
+
+// @public (undocumented)
+type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+interface FragmentRegistryAPI {
+    // (undocumented)
+    lookup(fragmentName: string): FragmentDefinitionNode | null;
+    // (undocumented)
+    register(...fragments: DocumentNode[]): this;
+    // (undocumented)
+    transform<D extends DocumentNode>(document: D): D;
+}
+
+// @public (undocumented)
+interface FulfilledPromise<TValue> extends Promise<TValue> {
+    // (undocumented)
+    status: "fulfilled";
+    // (undocumented)
+    value: TValue;
+}
+
+// @public (undocumented)
+export function getDefaultValues(definition: OperationDefinitionNode | undefined): Record<string, any>;
+
+// @public (undocumented)
+export type GetDirectiveConfig = GetNodeConfig<DirectiveNode>;
+
+// @public (undocumented)
+export function getDirectiveNames(root: ASTNode): string[];
+
+// @public (undocumented)
+export function getFragmentDefinition(doc: DocumentNode): FragmentDefinitionNode;
+
+// @public (undocumented)
+export function getFragmentDefinitions(doc: DocumentNode): FragmentDefinitionNode[];
+
+// @public (undocumented)
+export function getFragmentFromSelection(selection: SelectionNode, fragmentMap?: FragmentMap | FragmentMapFunction): InlineFragmentNode | FragmentDefinitionNode | null;
+
+// @public (undocumented)
+export function getFragmentQueryDocument(document: DocumentNode, fragmentName?: string): DocumentNode;
+
+// @public (undocumented)
+export type GetFragmentSpreadConfig = GetNodeConfig<FragmentSpreadNode>;
+
+// @public (undocumented)
+export function getGraphQLErrorsFromResult<T>(result: FetchResult<T>): GraphQLError[];
+
+// @public (undocumented)
+export function getInclusionDirectives(directives: ReadonlyArray<DirectiveNode>): InclusionDirectives;
+
+// @public (undocumented)
+export function getMainDefinition(queryDoc: DocumentNode): OperationDefinitionNode | FragmentDefinitionNode;
+
+// @public (undocumented)
+export type GetNodeConfig<N> = {
+    name?: string;
+    test?: (node: N) => boolean;
+};
+
+// @public (undocumented)
+export function getOperationDefinition(doc: DocumentNode): OperationDefinitionNode | undefined;
+
+// @public (undocumented)
+export function getOperationName(doc: DocumentNode): string | null;
+
+// @public (undocumented)
+export function getQueryDefinition(doc: DocumentNode): OperationDefinitionNode;
+
+// @public (undocumented)
+export const getStoreKeyName: ((fieldName: string, args?: Record<string, any> | null, directives?: Directives) => string) & {
+    setStringify(s: typeof stringify): (value: any) => string;
+};
+
+// @public (undocumented)
+export function getTypenameFromResult(result: Record<string, any>, selectionSet: SelectionSetNode, fragmentMap?: FragmentMap): string | undefined;
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export function graphQLResultHasError<T>(result: FetchResult<T>): boolean;
+
+// @public (undocumented)
+export const hasAllDirectives: (names: string[], root: ASTNode) => boolean;
+
+// @public (undocumented)
+export const hasAnyDirectives: (names: string[], root: ASTNode) => boolean;
+
+// @public (undocumented)
+export function hasClientExports(document: DocumentNode): boolean;
+
+// @public (undocumented)
+export function hasDirectives(names: string[], root: ASTNode, all?: boolean): boolean;
+
+// Warning: (ae-forgotten-export) The symbol "IdGetterObj" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IdGetter = (value: IdGetterObj) => string | undefined;
+
+// @public (undocumented)
+interface IdGetterObj extends Object {
+    // (undocumented)
+    __typename?: string;
+    // (undocumented)
+    id?: string;
+    // (undocumented)
+    _id?: string;
+}
+
+// @public (undocumented)
+export type InclusionDirectives = Array<{
+    directive: DirectiveNode;
+    ifArgument: ArgumentNode;
+}>;
+
+// @public (undocumented)
+interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+class InMemoryCache extends ApolloCache<NormalizedCacheObject> {
+    constructor(config?: InMemoryCacheConfig);
+    // (undocumented)
+    readonly assumeImmutableResults = true;
+    // (undocumented)
+    batch<TUpdateResult>(options: Cache_2.BatchOptions<InMemoryCache, TUpdateResult>): TUpdateResult;
+    // Warning: (ae-forgotten-export) The symbol "BroadcastOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected broadcastWatches(options?: BroadcastOptions): void;
+    // Warning: (ae-forgotten-export) The symbol "InMemoryCacheConfig" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected config: InMemoryCacheConfig;
+    // (undocumented)
+    diff<TData, TVariables extends OperationVariables = any>(options: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    extract(optimistic?: boolean): NormalizedCacheObject;
+    // (undocumented)
+    gc(options?: {
+        resetResultCache?: boolean;
+        resetResultIdentities?: boolean;
+    }): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // Warning: (ae-forgotten-export) The symbol "makeVar" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly makeVar: typeof makeVar;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any;
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    read<T>(options: Cache_2.ReadOptions): T | null;
+    // (undocumented)
+    release(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    removeOptimistic(idToRemove: string): void;
+    // (undocumented)
+    reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    restore(data: NormalizedCacheObject): this;
+    // (undocumented)
+    retain(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    write(options: Cache_2.WriteOptions): Reference | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloReducerConfig" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface InMemoryCacheConfig extends ApolloReducerConfig {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FragmentRegistryAPI" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fragments?: FragmentRegistryAPI;
+    // Warning: (ae-forgotten-export) The symbol "PossibleTypesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    possibleTypes?: PossibleTypesMap;
+    // (undocumented)
+    resultCacheMaxSize?: number;
+    // (undocumented)
+    resultCaching?: boolean;
+    // Warning: (ae-forgotten-export) The symbol "TypePolicies" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    typePolicies?: TypePolicies;
+}
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesInclude" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueryDescriptor" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "ApolloPayloadResult" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function isApolloPayloadResult(value: unknown): value is ApolloPayloadResult;
+
+// @public (undocumented)
+export const isArray: (a: any) => a is any[] | readonly any[];
+
+// @public (undocumented)
+export function isDocumentNode(value: any): value is DocumentNode;
+
+// @public (undocumented)
+export function isExecutionPatchIncrementalResult<T>(value: FetchResult<T>): value is ExecutionPatchIncrementalResult;
+
+// @public (undocumented)
+export function isExecutionPatchInitialResult<T>(value: FetchResult<T>): value is ExecutionPatchInitialResult<T>;
+
+// @public (undocumented)
+export function isExecutionPatchResult<T>(value: FetchResult<T>): value is ExecutionPatchResult<T>;
+
+// @public (undocumented)
+export function isField(selection: SelectionNode): selection is FieldNode;
+
+// @public (undocumented)
+export function isInlineFragment(selection: SelectionNode): selection is InlineFragmentNode;
+
+// @public (undocumented)
+export function isMutationOperation(document: DocumentNode): boolean;
+
+// @public (undocumented)
+export function isNonEmptyArray<T>(value?: ArrayLike<T>): value is Array<T>;
+
+// @public (undocumented)
+export function isNonNullObject(obj: any): obj is Record<string | number, any>;
+
+// @public (undocumented)
+export function isPlainObject(obj: any): obj is Record<string | number, any>;
+
+// @public (undocumented)
+export function isQueryOperation(document: DocumentNode): boolean;
+
+// @public (undocumented)
+export function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "PromiseWithState" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function isStatefulPromise<TValue>(promise: Promise<TValue>): promise is PromiseWithState<TValue>;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+export function isSubscriptionOperation(document: DocumentNode): boolean;
+
+// @public (undocumented)
+export function iterateObserversSafely<E, A>(observers: Set<Observer<E>>, method: keyof Observer<E>, argument?: A): void;
+
+// @public (undocumented)
+type KeyArgs = FieldPolicy<any>["keyArgs"];
+
+// Warning: (ae-forgotten-export) The symbol "IdGetter" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type KeyArgsFunction = (args: Record<string, any> | null, context: {
+    typename: string;
+    fieldName: string;
+    field: FieldNode | null;
+    variables?: Record<string, any>;
+}) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeyFieldsContext = {
+    typename: string | undefined;
+    storeObject: StoreObject;
+    readField: ReadFieldFunction;
+    selectionSet?: SelectionSetNode;
+    fragmentMap?: FragmentMap;
+    keyObject?: Record<string, any>;
+};
+
+// Warning: (ae-forgotten-export) The symbol "KeyFieldsContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type KeyFieldsFunction = (object: Readonly<StoreObject>, context: KeyFieldsContext) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeySpecifier = ReadonlyArray<string | KeySpecifier>;
+
+// @public (undocumented)
+class Layer extends EntityStore {
+    constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup);
+    // (undocumented)
+    addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    getStorage(): StorageType;
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly parent: EntityStore;
+    // (undocumented)
+    removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    readonly replay: (layer: EntityStore) => any;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+}
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+export function makeReference(id: string): Reference;
+
+// @public (undocumented)
+export function makeUniqueId(prefix: string): string;
+
+// Warning: (ae-forgotten-export) The symbol "ReactiveVar" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+function makeVar<T>(value: T): ReactiveVar<T>;
+
+// @public (undocumented)
+export function maybe<T>(thunk: () => T): T | undefined;
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+export function maybeDeepFreeze<T>(obj: T): T;
+
+// @public (undocumented)
+export function mergeDeep<T extends any[]>(...sources: T): TupleToIntersection<T>;
+
+// @public (undocumented)
+export function mergeDeepArray<T>(sources: T[]): T;
+
+// @public (undocumented)
+export function mergeIncrementalData<TData extends object>(prevResult: TData, result: ExecutionPatchResult<TData>): TData;
+
+// @public (undocumented)
+interface MergeInfo {
+    // (undocumented)
+    field: FieldNode;
+    // (undocumented)
+    merge: FieldMergeFunction;
+    // (undocumented)
+    typename: string | undefined;
+}
+
+// @public (undocumented)
+type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;
+
+// Warning: (ae-forgotten-export) The symbol "OptionsUnion" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function mergeOptions<TDefaultOptions extends Partial<OptionsUnion<any, any, any>>, TOptions extends TDefaultOptions>(defaults: TDefaultOptions | Partial<TDefaultOptions> | undefined, options: TOptions | Partial<TOptions>): TOptions & TDefaultOptions;
+
+// @public (undocumented)
+interface MergeTree {
+    // Warning: (ae-forgotten-export) The symbol "MergeInfo" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    info?: MergeInfo;
+    // (undocumented)
+    map: Map<string | number, MergeTree>;
+}
+
+// @public (undocumented)
+class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // Warning: (ae-forgotten-export) The symbol "ErrorPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // Warning: (ae-forgotten-export) The symbol "OnQueryUpdated" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // Warning: (ae-forgotten-export) The symbol "MutationUpdaterFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // Warning: (ae-forgotten-export) The symbol "MutationQueryReducersMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "FetchPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // Warning: (ae-forgotten-export) The symbol "WatchQueryFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+interface NormalizedCache {
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string): boolean;
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "FieldValueGetter" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: FieldValueGetter;
+    // (undocumented)
+    getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    merge(olderId: string, newerObject: StoreObject): void;
+    // (undocumented)
+    merge(olderObject: StoreObject, newerId: string): void;
+    // (undocumented)
+    modify<Entity extends Record<string, any>>(dataId: string, fields: Modifiers<Entity> | AllFieldsModifier<Entity>): boolean;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+interface NormalizedCacheObject {
+    // (undocumented)
+    [dataId: string]: StoreObject | undefined;
+    // (undocumented)
+    __META?: {
+        extraRootIds: string[];
+    };
+}
+
+export { Observable }
+
+// @public (undocumented)
+class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreQueryOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): ObservableSubscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): ObservableSubscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+export { ObservableSubscription }
+
+export { Observer }
+
+// @public (undocumented)
+export function offsetLimitPagination<T = Reference>(keyArgs?: KeyArgs): FieldPolicy<T[]>;
+
+// @public (undocumented)
+export function omitDeep<T, K extends string>(value: T, key: K): DeepOmit<T, K>;
+
+// @public (undocumented)
+type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+type OptionsUnion<TData, TVariables extends OperationVariables, TContext> = WatchQueryOptions<TVariables, TData> | QueryOptions<TVariables, TData> | MutationOptions<TData, TVariables, TContext>;
+
+// @public (undocumented)
+type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+interface PendingPromise<TValue> extends Promise<TValue> {
+    // (undocumented)
+    status: "pending";
+}
+
+// @public (undocumented)
+class Policies {
+    constructor(config: {
+        cache: InMemoryCache;
+        dataIdFromObject?: KeyFieldsFunction;
+        possibleTypes?: PossibleTypesMap;
+        typePolicies?: TypePolicies;
+    });
+    // (undocumented)
+    addPossibleTypes(possibleTypes: PossibleTypesMap): void;
+    // (undocumented)
+    addTypePolicies(typePolicies: TypePolicies): void;
+    // (undocumented)
+    readonly cache: InMemoryCache;
+    // (undocumented)
+    fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string | undefined, result?: Record<string, any>, variables?: Record<string, any>): boolean;
+    // (undocumented)
+    getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
+    // (undocumented)
+    getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
+    // Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getStoreFieldName(fieldSpec: FieldSpecifier): string;
+    // (undocumented)
+    hasKeyArgs(typename: string | undefined, fieldName: string): boolean;
+    // (undocumented)
+    identify(object: StoreObject, partialContext?: Partial<KeyFieldsContext>): [string?, StoreObject?];
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ReadMergeModifyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
+    // (undocumented)
+    readonly rootIdsByTypename: Record<string, string>;
+    // (undocumented)
+    readonly rootTypenamesById: Record<string, string>;
+    // (undocumented)
+    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
+    // (undocumented)
+    readonly usingPossibleTypes = false;
+}
+
+// @public (undocumented)
+type PossibleTypesMap = {
+    [supertype: string]: string[];
+};
+
+// @public (undocumented)
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+
+// @public (undocumented)
+const print_2: typeof print_3;
+export { print_2 as print }
+
+// Warning: (ae-forgotten-export) The symbol "PendingPromise" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type PromiseWithState<TValue> = PendingPromise<TValue> | FulfilledPromise<TValue> | RejectedPromise<TValue>;
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // Warning: (ae-forgotten-export) The symbol "QueryListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<ObservableSubscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // Warning: (ae-forgotten-export) The symbol "DefaultOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesOptions" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "InternalRefetchQueriesMap" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+type ReactiveListener<T> = (value: T) => any;
+
+// @public (undocumented)
+interface ReactiveVar<T> {
+    // (undocumented)
+    (newValue?: T): T;
+    // (undocumented)
+    attachCache(cache: ApolloCache<any>): this;
+    // (undocumented)
+    forgetCache(cache: ApolloCache<any>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onNextChange(listener: ReactiveListener<T>): () => void;
+}
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+interface ReadMergeModifyContext {
+    // (undocumented)
+    store: NormalizedCache;
+    // (undocumented)
+    variables?: Record<string, any>;
+    // (undocumented)
+    varString?: string;
+}
+
+// @public (undocumented)
+export type ReconcilerFunction<TContextArgs extends any[]> = (this: DeepMerger<TContextArgs>, target: Record<string | number, any>, source: Record<string | number, any>, property: string | number, ...context: TContextArgs) => any;
+
+// @public (undocumented)
+export interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// @public (undocumented)
+type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesPromiseResults" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+interface RejectedPromise<TValue> extends Promise<TValue> {
+    // (undocumented)
+    reason: unknown;
+    // (undocumented)
+    status: "rejected";
+}
+
+// Warning: (ae-forgotten-export) The symbol "TExistingRelay" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "TIncomingRelay" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type RelayFieldPolicy<TNode> = FieldPolicy<TExistingRelay<TNode> | null, TIncomingRelay<TNode> | null, TIncomingRelay<TNode> | null>;
+
+// Warning: (ae-forgotten-export) The symbol "RelayFieldPolicy" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function relayStylePagination<TNode extends Reference = Reference>(keyArgs?: KeyArgs): RelayFieldPolicy<TNode>;
+
+// @public (undocumented)
+export type RemoveArgumentsConfig = RemoveNodeConfig<ArgumentNode>;
+
+// @public (undocumented)
+export function removeArgumentsFromDocument(config: RemoveArgumentsConfig[], doc: DocumentNode): DocumentNode | null;
+
+// @public (undocumented)
+export function removeClientSetsFromDocument(document: DocumentNode): DocumentNode | null;
+
+// @public (undocumented)
+export function removeConnectionDirectiveFromDocument(doc: DocumentNode): DocumentNode | null;
+
+// @public (undocumented)
+export type RemoveDirectiveConfig = RemoveNodeConfig<DirectiveNode>;
+
+// @public (undocumented)
+export function removeDirectivesFromDocument(directives: RemoveDirectiveConfig[], doc: DocumentNode): DocumentNode | null;
+
+// @public (undocumented)
+export type RemoveFragmentDefinitionConfig = RemoveNodeConfig<FragmentDefinitionNode>;
+
+// @public (undocumented)
+export type RemoveFragmentSpreadConfig = RemoveNodeConfig<FragmentSpreadNode>;
+
+// @public (undocumented)
+export function removeFragmentSpreadFromDocument(config: RemoveFragmentSpreadConfig[], doc: DocumentNode): DocumentNode | null;
+
+// @public (undocumented)
+export type RemoveNodeConfig<N> = {
+    name?: string;
+    test?: (node: N) => boolean;
+    remove?: boolean;
+};
+
+// @public (undocumented)
+export type RemoveVariableDefinitionConfig = RemoveNodeConfig<VariableDefinitionNode>;
+
+// @public (undocumented)
+type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// @public (undocumented)
+export function resultKeyNameFromField(field: FieldNode): string;
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// @public (undocumented)
+type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+// @public (undocumented)
+export function shouldInclude({ directives }: SelectionNode, variables?: Record<string, any>): boolean;
+
+// @public (undocumented)
+interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+export function storeKeyNameFromField(field: FieldNode, variables?: Object): string;
+
+// @public (undocumented)
+export interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+export type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+let stringify: (value: any) => string;
+
+// @public (undocumented)
+export function stringifyForDisplay(value: any, space?: number): string;
+
+// @public (undocumented)
+export function stripTypename<T>(value: T): DeepOmit<T, "__typename">;
+
+// @public (undocumented)
+class Stump extends Layer {
+    constructor(root: EntityStore.Root);
+    // (undocumented)
+    merge(): any;
+    // (undocumented)
+    removeLayer(): this;
+}
+
+// @public (undocumented)
+type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+type TExistingRelay<TNode> = Readonly<{
+    edges: TRelayEdge<TNode>[];
+    pageInfo: TRelayPageInfo;
+}>;
+
+// @public (undocumented)
+type TIncomingRelay<TNode> = {
+    edges?: TRelayEdge<TNode>[];
+    pageInfo?: TRelayPageInfo;
+};
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+// @public (undocumented)
+type TRelayEdge<TNode> = {
+    cursor?: string;
+    node: TNode;
+} | (Reference & {
+    cursor?: string;
+});
+
+// @public (undocumented)
+type TRelayPageInfo = {
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    startCursor: string;
+    endCursor: string;
+};
+
+// @public (undocumented)
+export type TupleToIntersection<T extends any[]> = T extends [infer A] ? A : T extends [infer A, infer B] ? A & B : T extends [infer A, infer B, infer C] ? A & B & C : T extends [infer A, infer B, infer C, infer D] ? A & B & C & D : T extends [infer A, infer B, infer C, infer D, infer E] ? A & B & C & D & E : T extends (infer U)[] ? U : any;
+
+// @public (undocumented)
+type TypePolicies = {
+    [__typename: string]: TypePolicy;
+};
+
+// @public (undocumented)
+type TypePolicy = {
+    keyFields?: KeySpecifier | KeyFieldsFunction | false;
+    merge?: FieldMergeFunction | boolean;
+    queryType?: true;
+    mutationType?: true;
+    subscriptionType?: true;
+    fields?: {
+        [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
+    };
+};
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export function valueToObjectRepresentation(argObj: any, name: NameNode, value: ValueNode, variables?: Object): void;
+
+// @public (undocumented)
+export type VariableValue = (node: VariableNode) => any;
+
+// @public (undocumented)
+type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// @public (undocumented)
+export function wrapPromiseWithState<TValue>(promise: Promise<TValue>): PromiseWithState<TValue>;
+
+// @public (undocumented)
+interface WriteContext extends ReadMergeModifyContext {
+    // (undocumented)
+    clientOnly: boolean;
+    // (undocumented)
+    deferred: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FlavorableWriteContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    flavors: Map<string, FlavorableWriteContext>;
+    // (undocumented)
+    readonly fragmentMap: FragmentMap;
+    // (undocumented)
+    incomingById: Map<string, {
+        storeObject: StoreObject;
+        mergeTree?: MergeTree;
+        fieldNodeSet: Set<FieldNode>;
+    }>;
+    // (undocumented)
+    lookupFragment: FragmentMapFunction;
+    // (undocumented)
+    merge<T>(existing: T, incoming: T): T;
+    // (undocumented)
+    overwrite: boolean;
+    // (undocumented)
+    readonly written: {
+        [dataId: string]: SelectionSetNode[];
+    };
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/core/types/DataProxy.ts:141:5 - (ae-forgotten-export) The symbol "MissingFieldError" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:63:3 - (ae-forgotten-export) The symbol "TypePolicy" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeySpecifier" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeyArgsFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:168:3 - (ae-forgotten-export) The symbol "FieldReadFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:169:3 - (ae-forgotten-export) The symbol "FieldMergeFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/types.ts:126:3 - (ae-forgotten-export) The symbol "KeyFieldsFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/writeToStore.ts:65:7 - (ae-forgotten-export) The symbol "MergeTree" needs to be exported by the entry point index.d.ts
+// src/core/ApolloClient.ts:47:3 - (ae-forgotten-export) The symbol "UriFunction" needs to be exported by the entry point index.d.ts
+// src/core/LocalState.ts:71:3 - (ae-forgotten-export) The symbol "ApolloClient" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:158:3 - (ae-forgotten-export) The symbol "ApolloError" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:160:3 - (ae-forgotten-export) The symbol "NetworkStatus" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:178:3 - (ae-forgotten-export) The symbol "MutationQueryReducer" needs to be exported by the entry point index.d.ts
+// src/core/types.ts:205:5 - (ae-forgotten-export) The symbol "Resolver" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/utilities/graphql/storeUtils.ts:202:12 - (ae-forgotten-export) The symbol "stringify" needs to be exported by the entry point index.d.ts
+// src/utilities/policies/pagination.ts:76:3 - (ae-forgotten-export) The symbol "TRelayEdge" needs to be exported by the entry point index.d.ts
+// src/utilities/policies/pagination.ts:77:3 - (ae-forgotten-export) The symbol "TRelayPageInfo" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report-utilities_globals.md b/.api-reports/api-report-utilities_globals.md
new file mode 100644
index 00000000000..2383be3ea83
--- /dev/null
+++ b/.api-reports/api-report-utilities_globals.md
@@ -0,0 +1,51 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { InvariantError } from 'ts-invariant';
+
+// @public (undocumented)
+const DEV: boolean;
+export { DEV }
+export { DEV as __DEV__ }
+
+// @public (undocumented)
+const global_2: typeof globalThis & Window;
+export { global_2 as global }
+
+// Warning: (ae-forgotten-export) The symbol "WrappedInvariant" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const invariant: WrappedInvariant;
+
+export { InvariantError }
+
+// @public (undocumented)
+type LogFunction = {
+    (message?: any, ...optionalParams: unknown[]): void;
+};
+
+// @public (undocumented)
+export function maybe<T>(thunk: () => T): T | undefined;
+
+// @public (undocumented)
+export function newInvariantError(message?: string | number, ...optionalParams: unknown[]): InvariantError;
+
+// @public (undocumented)
+type WrappedInvariant = {
+    (condition: any, message?: string | number, ...optionalParams: unknown[]): asserts condition;
+    debug: LogFunction;
+    log: LogFunction;
+    warn: LogFunction;
+    error: LogFunction;
+};
+
+// Warnings were encountered during analysis:
+//
+// src/utilities/globals/invariantWrappers.ts:58:3 - (ae-forgotten-export) The symbol "LogFunction" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```
diff --git a/.api-reports/api-report.md b/.api-reports/api-report.md
new file mode 100644
index 00000000000..01950a8f066
--- /dev/null
+++ b/.api-reports/api-report.md
@@ -0,0 +1,2902 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="react" />
+
+import type { ASTNode } from 'graphql';
+import { disableExperimentalFragmentVariables } from 'graphql-tag';
+import { disableFragmentWarnings } from 'graphql-tag';
+import type { DocumentNode } from 'graphql';
+import { enableExperimentalFragmentVariables } from 'graphql-tag';
+import type { ExecutionResult } from 'graphql';
+import type { FieldNode } from 'graphql';
+import type { FragmentDefinitionNode } from 'graphql';
+import { gql } from 'graphql-tag';
+import type { GraphQLError } from 'graphql';
+import type { GraphQLErrorExtensions } from 'graphql';
+import type { InlineFragmentNode } from 'graphql';
+import { InvariantError } from 'ts-invariant';
+import { Observable } from 'zen-observable-ts';
+import type { Subscription as ObservableSubscription } from 'zen-observable-ts';
+import type { Observer } from 'zen-observable-ts';
+import { print as print_3 } from 'graphql';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import { resetCaches } from 'graphql-tag';
+import type { SelectionSetNode } from 'graphql';
+import { setVerbosity as setLogVerbosity } from 'ts-invariant';
+import type { Subscriber } from 'zen-observable-ts';
+import { Trie } from '@wry/trie';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { VariableDefinitionNode } from 'graphql';
+
+// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
+
+// @public (undocumented)
+export abstract class ApolloCache<TSerialized> implements DataProxy {
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
+    // (undocumented)
+    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
+    // (undocumented)
+    abstract evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    abstract extract(optimistic?: boolean): TSerialized;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
+    // (undocumented)
+    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
+    // (undocumented)
+    abstract removeOptimistic(id: string): void;
+    // (undocumented)
+    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    transformForLink(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    // (undocumented)
+    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export class ApolloClient<TCacheShape> implements DataProxy {
+    // (undocumented)
+    __actionHookForDevTools(cb: () => any): void;
+    constructor(options: ApolloClientOptions<TCacheShape>);
+    // (undocumented)
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    cache: ApolloCache<TCacheShape>;
+    // (undocumented)
+    clearStore(): Promise<any[]>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    disableNetworkFetches: boolean;
+    // (undocumented)
+    get documentTransform(): DocumentTransform;
+    // (undocumented)
+    extract(optimistic?: boolean): TCacheShape;
+    // (undocumented)
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    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<FetchResult<TData>>;
+    // (undocumented)
+    onClearStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    onResetStore(cb: () => Promise<any>): () => void;
+    // (undocumented)
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
+    // (undocumented)
+    queryDeduplication: boolean;
+    // (undocumented)
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // (undocumented)
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    // (undocumented)
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    // (undocumented)
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    // (undocumented)
+    setLink(newLink: ApolloLink): void;
+    // (undocumented)
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
+    // (undocumented)
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
+    // (undocumented)
+    version: string;
+    // (undocumented)
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// @public (undocumented)
+export type ApolloClientOptions<TCacheShape> = {
+    uri?: string | UriFunction;
+    credentials?: string;
+    headers?: Record<string, string>;
+    link?: ApolloLink;
+    cache: ApolloCache<TCacheShape>;
+    ssrForceFetchDelay?: number;
+    ssrMode?: boolean;
+    connectToDevTools?: boolean;
+    queryDeduplication?: boolean;
+    defaultOptions?: DefaultOptions;
+    assumeImmutableResults?: boolean;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
+    name?: string;
+    version?: string;
+    documentTransform?: DocumentTransform;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ApolloConsumerProps" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const ApolloConsumer: React_2.FC<ApolloConsumerProps>;
+
+// @public (undocumented)
+interface ApolloConsumerProps {
+    // (undocumented)
+    children: (client: ApolloClient<object>) => React_2.ReactChild | null;
+}
+
+// @public (undocumented)
+export interface ApolloContextValue {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // Warning: (ae-forgotten-export) The symbol "RenderPromises" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    renderPromises?: RenderPromises;
+}
+
+// @public (undocumented)
+export class ApolloError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
+    // (undocumented)
+    clientErrors: ReadonlyArray<Error>;
+    // (undocumented)
+    extraInfo: any;
+    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    graphQLErrors: GraphQLErrors;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    networkError: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+interface ApolloErrorOptions {
+    // (undocumented)
+    clientErrors?: ReadonlyArray<Error>;
+    // (undocumented)
+    errorMessage?: string;
+    // (undocumented)
+    extraInfo?: any;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    networkError?: Error | ServerParseError | ServerError | null;
+    // (undocumented)
+    protocolErrors?: ReadonlyArray<{
+        message: string;
+        extensions?: GraphQLErrorExtensions[];
+    }>;
+}
+
+// @public (undocumented)
+export class ApolloLink {
+    constructor(request?: RequestHandler);
+    // (undocumented)
+    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    concat(next: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    static empty(): ApolloLink;
+    // (undocumented)
+    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
+    // (undocumented)
+    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
+    // (undocumented)
+    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
+    // (undocumented)
+    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
+    // (undocumented)
+    setOnError(fn: ApolloLink["onError"]): this;
+    // (undocumented)
+    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+    // (undocumented)
+    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
+}
+
+// @public (undocumented)
+export interface ApolloPayloadResult<TData = Record<string, any>, TExtensions = Record<string, any>> {
+    // (undocumented)
+    errors?: ReadonlyArray<Error | string>;
+    // (undocumented)
+    payload: SingleExecutionResult | ExecutionPatchResult | null;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ApolloProviderProps" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const ApolloProvider: React_2.FC<ApolloProviderProps<any>>;
+
+// @public (undocumented)
+interface ApolloProviderProps<TCache> {
+    // (undocumented)
+    children: React_2.ReactNode | React_2.ReactNode[] | null;
+    // (undocumented)
+    client: ApolloClient<TCache>;
+}
+
+// @public (undocumented)
+export type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    error?: ApolloError;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    partial?: boolean;
+};
+
+// @public (undocumented)
+export type ApolloReducerConfig = {
+    dataIdFromObject?: KeyFieldsFunction;
+    addTypename?: boolean;
+};
+
+// @public (undocumented)
+export type BackgroundQueryHookFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
+
+// @public (undocumented)
+export interface BackgroundQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick<QueryHookOptions<TData, TVariables>, "client" | "variables" | "errorPolicy" | "context" | "canonizeResults" | "returnPartialData" | "refetchWritePolicy"> {
+    // (undocumented)
+    fetchPolicy?: BackgroundQueryHookFetchPolicy;
+    // (undocumented)
+    queryKey?: string | number | any[];
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    suspenseCache?: SuspenseCache;
+}
+
+// @public (undocumented)
+type BackgroundQueryHookOptionsNoInfer<TData, TVariables extends OperationVariables> = BackgroundQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>;
+
+// @public (undocumented)
+export interface BaseMutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, "mutation"> {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    ignoreResults?: boolean;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;
+    // (undocumented)
+    onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;
+}
+
+// @public (undocumented)
+export interface BaseQueryOptions<TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, "query"> {
+    // (undocumented)
+    client?: ApolloClient<any>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    ssr?: boolean;
+}
+
+// @public (undocumented)
+export interface BaseSubscriptionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client?: ApolloClient<object>;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    onComplete?: () => void;
+    // (undocumented)
+    onData?: (options: OnDataOptions<TData>) => any;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    onSubscriptionComplete?: () => void;
+    // (undocumented)
+    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any;
+    // (undocumented)
+    shouldResubscribe?: boolean | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean);
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface Body_2 {
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+type BroadcastOptions = Pick<Cache_2.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
+
+// @public (undocumented)
+namespace Cache_2 {
+    // (undocumented)
+    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+        // (undocumented)
+        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => any;
+        // (undocumented)
+        optimistic?: string | boolean;
+        // (undocumented)
+        removeOptimistic?: string;
+        // (undocumented)
+        update(cache: TCache): TUpdateResult;
+    }
+    // (undocumented)
+    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    }
+    // (undocumented)
+    interface EvictOptions {
+        // (undocumented)
+        args?: Record<string, any>;
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        fieldName?: string;
+        // (undocumented)
+        id?: string;
+    }
+    // (undocumented)
+    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
+        // (undocumented)
+        broadcast?: boolean;
+        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
+        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        optimistic?: boolean;
+    }
+    // (undocumented)
+    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic: boolean;
+        // (undocumented)
+        previousResult?: any;
+        // (undocumented)
+        returnPartialData?: boolean;
+        // (undocumented)
+        rootId?: string;
+    }
+    // (undocumented)
+    interface ResetOptions {
+        // (undocumented)
+        discardWatches?: boolean;
+    }
+    // (undocumented)
+    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
+    // (undocumented)
+    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+        // (undocumented)
+        callback: WatchCallback<TData>;
+        // (undocumented)
+        immediate?: boolean;
+        // (undocumented)
+        lastDiff?: DiffResult<TData>;
+        // (undocumented)
+        watcher?: object;
+    }
+    // (undocumented)
+    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
+        // (undocumented)
+        dataId?: string;
+        // (undocumented)
+        result: TResult;
+    }
+    import DiffResult = DataProxy.DiffResult;
+    import ReadQueryOptions = DataProxy.ReadQueryOptions;
+    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
+    import WriteQueryOptions = DataProxy.WriteQueryOptions;
+    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
+    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
+    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
+    import Fragment = DataProxy.Fragment;
+}
+export { Cache_2 as Cache }
+
+// @public (undocumented)
+class CacheGroup {
+    constructor(caching: boolean, parent?: CacheGroup | null);
+    // (undocumented)
+    readonly caching: boolean;
+    // (undocumented)
+    depend(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    dirty(dataId: string, storeFieldName: string): void;
+    // (undocumented)
+    keyMaker: Trie<object>;
+    // (undocumented)
+    resetCaching(): void;
+}
+
+// @public (undocumented)
+type CacheKey = [
+query: DocumentNode,
+stringifiedVariables: string,
+...queryKey: any[]
+];
+
+// @public (undocumented)
+const enum CacheWriteBehavior {
+    // (undocumented)
+    FORBID = 0,
+    // (undocumented)
+    MERGE = 2,
+    // (undocumented)
+    OVERWRITE = 1
+}
+
+// @public (undocumented)
+type CanReadFunction = (value: StoreValue) => boolean;
+
+// @public (undocumented)
+export const checkFetcher: (fetcher: WindowOrWorkerGlobalScope["fetch"] | undefined) => void;
+
+// @public (undocumented)
+export type ClientParseError = InvariantError & {
+    parseError: Error;
+};
+
+// @public (undocumented)
+export type CommonOptions<TOptions> = TOptions & {
+    client?: ApolloClient<object>;
+};
+
+// @public (undocumented)
+class Concast<T> extends Observable<T> {
+    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
+    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
+    // (undocumented)
+    addObserver(observer: Observer<T>): void;
+    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    beforeNext(callback: NextResultListener): void;
+    // (undocumented)
+    cancel: (reason: any) => void;
+    // (undocumented)
+    readonly promise: Promise<T>;
+    // (undocumented)
+    removeObserver(observer: Observer<T>): void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ConcastSourcesIterable<T> = Iterable<Source<T>>;
+
+// @public (undocumented)
+export const concat: typeof ApolloLink.concat;
+
+// @public (undocumented)
+export const createHttpLink: (linkOptions?: HttpOptions) => ApolloLink;
+
+// @public (undocumented)
+export const createSignalIfSupported: () => {
+    controller: boolean;
+    signal: boolean;
+} | {
+    controller: AbortController;
+    signal: AbortSignal;
+};
+
+// @public (undocumented)
+export namespace DataProxy {
+    // (undocumented)
+    export type DiffResult<T> = {
+        result?: T;
+        complete?: boolean;
+        missing?: MissingFieldError[];
+        fromOptimisticTransaction?: boolean;
+    };
+    // (undocumented)
+    export interface Fragment<TVariables, TData> {
+        // (undocumented)
+        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        fragmentName?: string;
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    export interface Query<TVariables, TData> {
+        // (undocumented)
+        id?: string;
+        // (undocumented)
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        // (undocumented)
+        variables?: TVariables;
+    }
+    // (undocumented)
+    export interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // (undocumented)
+    export interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        // (undocumented)
+        canonizeResults?: boolean;
+        // (undocumented)
+        optimistic?: boolean;
+        // (undocumented)
+        returnPartialData?: boolean;
+    }
+    // (undocumented)
+    export interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    export interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
+    }
+    // (undocumented)
+    export interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
+    }
+    // (undocumented)
+    export interface WriteOptions<TData> {
+        // (undocumented)
+        broadcast?: boolean;
+        // (undocumented)
+        data: TData;
+        // (undocumented)
+        overwrite?: boolean;
+    }
+    // (undocumented)
+    export interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
+    }
+}
+
+// @public (undocumented)
+export interface DataProxy {
+    // (undocumented)
+    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    // (undocumented)
+    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    // (undocumented)
+    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    // (undocumented)
+    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+}
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartialPrimitive" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlyMap" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialSet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialReadonlySet" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeepPartialObject" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartial<T> = T extends DeepPartialPrimitive ? T : T extends Map<infer TKey, infer TValue> ? DeepPartialMap<TKey, TValue> : T extends ReadonlyMap<infer TKey, infer TValue> ? DeepPartialReadonlyMap<TKey, TValue> : T extends Set<infer TItem> ? DeepPartialSet<TItem> : T extends ReadonlySet<infer TItem> ? DeepPartialReadonlySet<TItem> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends ReadonlyArray<infer TItem> ? TItem[] extends T ? readonly TItem[] extends T ? ReadonlyArray<DeepPartial<TItem | undefined>> : Array<DeepPartial<TItem | undefined>> : DeepPartialObject<T> : DeepPartialObject<T> : unknown;
+
+// Warning: (ae-forgotten-export) The symbol "DeepPartial" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartialMap<TKey, TValue> = {} & Map<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialObject<T extends object> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Primitive" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type DeepPartialPrimitive = Primitive | Date | RegExp;
+
+// @public (undocumented)
+type DeepPartialReadonlyMap<TKey, TValue> = {} & ReadonlyMap<DeepPartial<TKey>, DeepPartial<TValue>>;
+
+// @public (undocumented)
+type DeepPartialReadonlySet<T> = {} & ReadonlySet<DeepPartial<T>>;
+
+// @public (undocumented)
+type DeepPartialSet<T> = {} & Set<DeepPartial<T>>;
+
+// @public (undocumented)
+interface DefaultContext extends Record<string, any> {
+}
+export { DefaultContext as Context }
+export { DefaultContext }
+
+// Warning: (ae-forgotten-export) The symbol "KeyFieldsContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function defaultDataIdFromObject({ __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext): string | undefined;
+
+// @public (undocumented)
+export interface DefaultOptions {
+    // (undocumented)
+    mutate?: Partial<MutationOptions<any, any, any>>;
+    // (undocumented)
+    query?: Partial<QueryOptions<any, any>>;
+    // (undocumented)
+    watchQuery?: Partial<WatchQueryOptions<any, any>>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "Printer" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export const defaultPrinter: Printer;
+
+// @public (undocumented)
+interface DeleteModifier {
+    // (undocumented)
+    [_deleteModifier]: true;
+}
+
+// @public (undocumented)
+const _deleteModifier: unique symbol;
+
+// @public (undocumented)
+export type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
+    returnPartialData?: boolean;
+};
+
+export { disableExperimentalFragmentVariables }
+
+export { disableFragmentWarnings }
+
+export { DocumentNode }
+
+// @public (undocumented)
+export class DocumentTransform {
+    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
+    constructor(transform: TransformFn, options?: DocumentTransformOptions);
+    // (undocumented)
+    concat(otherTransform: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    getStableCacheEntry(document: DocumentNode): {
+        key: DocumentTransformCacheKey;
+        value?: DocumentNode | undefined;
+    } | undefined;
+    // (undocumented)
+    static identity(): DocumentTransform;
+    // (undocumented)
+    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+}
+
+// @public (undocumented)
+export type DocumentTransformCacheKey = ReadonlyArray<unknown>;
+
+// @public (undocumented)
+interface DocumentTransformOptions {
+    // (undocumented)
+    cache?: boolean;
+    // (undocumented)
+    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
+}
+
+// @public (undocumented)
+enum DocumentType_2 {
+    // (undocumented)
+    Mutation = 1,
+    // (undocumented)
+    Query = 0,
+    // (undocumented)
+    Subscription = 2
+}
+export { DocumentType_2 as DocumentType }
+
+// @public (undocumented)
+export const empty: typeof ApolloLink.empty;
+
+export { enableExperimentalFragmentVariables }
+
+// @public (undocumented)
+abstract class EntityStore implements NormalizedCache {
+    constructor(policies: Policies, group: CacheGroup);
+    // Warning: (ae-forgotten-export) The symbol "Layer" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // Warning: (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    protected data: NormalizedCacheObject;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string, args?: Record<string, any>): boolean;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions, limit: EntityStore): boolean;
+    // (undocumented)
+    extract(): NormalizedCacheObject;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    gc(): string[];
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
+    // (undocumented)
+    getRootIdSet(ids?: Set<string>): Set<string>;
+    // Warning: (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // Warning: (ae-forgotten-export) The symbol "CacheGroup" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    protected lookup(dataId: string, dependOnExistence?: boolean): StoreObject | undefined;
+    // (undocumented)
+    makeCacheKey(...args: any[]): object;
+    // (undocumented)
+    merge(older: string | StoreObject, newer: StoreObject | string): void;
+    // (undocumented)
+    modify(dataId: string, fields: Modifier<any> | Modifiers<Record<string, any>>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "Policies" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    abstract removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject | null): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // Warning: (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+namespace EntityStore {
+    // (undocumented)
+    class Root extends EntityStore {
+        constructor({ policies, resultCaching, seed, }: {
+            policies: Policies;
+            resultCaching?: boolean;
+            seed?: NormalizedCacheObject;
+        });
+        // (undocumented)
+        addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+        // (undocumented)
+        getStorage(): StorageType;
+        // (undocumented)
+        removeLayer(): Root;
+        // (undocumented)
+        readonly storageTrie: Trie<StorageType>;
+        // Warning: (ae-forgotten-export) The symbol "Stump" needs to be exported by the entry point index.d.ts
+        //
+        // (undocumented)
+        readonly stump: Stump;
+    }
+}
+
+// @public (undocumented)
+export type ErrorPolicy = "none" | "ignore" | "all";
+
+// @public (undocumented)
+export const execute: typeof ApolloLink.execute;
+
+// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data?: never;
+    // (undocumented)
+    errors?: never;
+    // (undocumented)
+    extensions?: never;
+    // (undocumented)
+    incremental?: IncrementalPayload<TData, TExtensions>[];
+}
+
+// @public (undocumented)
+export interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+    // (undocumented)
+    data: TData | null | undefined;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    incremental?: never;
+}
+
+// @public (undocumented)
+export type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
+
+// @public (undocumented)
+interface ExecutionPatchResultBase {
+    // (undocumented)
+    hasNext?: boolean;
+}
+
+// @public (undocumented)
+export const fallbackHttpConfig: {
+    http: HttpQueryOptions;
+    headers: {
+        accept: string;
+        "content-type": string;
+    };
+    options: {
+        method: string;
+    };
+};
+
+// @public (undocumented)
+type FetchMoreFunction<TData, TVariables extends OperationVariables> = (fetchMoreOptions: FetchMoreQueryOptions<TVariables, TData> & {
+    updateQuery?: (previousQueryResult: TData, options: {
+        fetchMoreResult: TData;
+        variables: TVariables;
+    }) => TData;
+}) => Promise<ApolloQueryResult<TData>>;
+
+// @public (undocumented)
+export interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {
+    // (undocumented)
+    updateQuery?: (previousQueryResult: TData, options: {
+        fetchMoreResult?: TData;
+        variables?: TVariables;
+    }) => TData;
+}
+
+// @public (undocumented)
+type FetchMoreOptions_2<TData> = Parameters<ObservableQuery<TData>["fetchMore"]>[0];
+
+// @public (undocumented)
+export interface FetchMoreQueryOptions<TVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: Partial<TVariables>;
+}
+
+// @public (undocumented)
+export type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";
+
+// @public (undocumented)
+export type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
+
+// @public (undocumented)
+export interface FieldFunctionOptions<TArgs = Record<string, any>, TVars = Record<string, any>> {
+    // (undocumented)
+    args: TArgs | null;
+    // (undocumented)
+    cache: InMemoryCache;
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    field: FieldNode | null;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    isReference: typeof isReference;
+    // Warning: (ae-forgotten-export) The symbol "MergeObjectsFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    mergeObjects: MergeObjectsFunction;
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField: ReadFieldFunction;
+    // (undocumented)
+    storage: StorageType;
+    // (undocumented)
+    storeFieldName: string;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+    // (undocumented)
+    variables?: TVars;
+}
+
+// @public (undocumented)
+export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
+
+// @public (undocumented)
+export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
+    keyArgs?: KeySpecifier | KeyArgsFunction | false;
+    read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
+    merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
+};
+
+// @public (undocumented)
+export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
+
+// @public (undocumented)
+interface FieldSpecifier {
+    // (undocumented)
+    args?: Record<string, any>;
+    // (undocumented)
+    field?: FieldNode;
+    // (undocumented)
+    fieldName: string;
+    // (undocumented)
+    typename?: string;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// Warning: (ae-forgotten-export) The symbol "EntityStore" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FieldValueGetter = EntityStore["getFieldValue"];
+
+// Warning: (ae-forgotten-export) The symbol "WriteContext" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type FlavorableWriteContext = Pick<WriteContext, "clientOnly" | "deferred" | "flavors">;
+
+// @public (undocumented)
+interface FragmentMap {
+    // (undocumented)
+    [fragmentName: string]: FragmentDefinitionNode;
+}
+
+// @public (undocumented)
+type FragmentMapFunction = (fragmentName: string) => FragmentDefinitionNode | null;
+
+// @public (undocumented)
+export type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+
+// @public (undocumented)
+interface FragmentRegistryAPI {
+    // (undocumented)
+    lookup(fragmentName: string): FragmentDefinitionNode | null;
+    // (undocumented)
+    register(...fragments: DocumentNode[]): this;
+    // (undocumented)
+    transform<D extends DocumentNode>(document: D): D;
+}
+
+// @public (undocumented)
+export const from: typeof ApolloLink.from;
+
+// @public (undocumented)
+export function fromError<T>(errorValue: any): Observable<T>;
+
+// @public (undocumented)
+export function fromPromise<T>(promise: Promise<T>): Observable<T>;
+
+// @public (undocumented)
+export function getApolloContext(): React_2.Context<ApolloContextValue>;
+
+export { gql }
+
+// @public (undocumented)
+type GraphQLErrors = ReadonlyArray<GraphQLError>;
+
+// @public (undocumented)
+export interface GraphQLRequest<TVariables = Record<string, any>> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    extensions?: Record<string, any>;
+    // (undocumented)
+    operationName?: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+interface HttpConfig {
+    // (undocumented)
+    credentials?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    http?: HttpQueryOptions;
+    // (undocumented)
+    options?: any;
+}
+
+// @public (undocumented)
+export class HttpLink extends ApolloLink {
+    constructor(options?: HttpOptions);
+    // (undocumented)
+    options: HttpOptions;
+    // (undocumented)
+    requester: RequestHandler;
+}
+
+// @public (undocumented)
+export interface HttpOptions {
+    // (undocumented)
+    credentials?: string;
+    // (undocumented)
+    fetch?: WindowOrWorkerGlobalScope["fetch"];
+    // (undocumented)
+    fetchOptions?: any;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeUnusedVariables?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+    // (undocumented)
+    print?: Printer;
+    // (undocumented)
+    uri?: string | UriFunction;
+    // (undocumented)
+    useGETForQueries?: boolean;
+}
+
+// @public (undocumented)
+interface HttpQueryOptions {
+    // (undocumented)
+    includeExtensions?: boolean;
+    // (undocumented)
+    includeQuery?: boolean;
+    // (undocumented)
+    preserveHeaderCase?: boolean;
+}
+
+// @public (undocumented)
+export type IdGetter = (value: IdGetterObj) => string | undefined;
+
+// @public (undocumented)
+export interface IdGetterObj extends Object {
+    // (undocumented)
+    __typename?: string;
+    // (undocumented)
+    id?: string;
+    // (undocumented)
+    _id?: string;
+}
+
+// @public (undocumented)
+export interface IDocumentDefinition {
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    type: DocumentType_2;
+    // (undocumented)
+    variables: ReadonlyArray<VariableDefinitionNode>;
+}
+
+// @public (undocumented)
+export interface IncrementalPayload<TData, TExtensions> {
+    // (undocumented)
+    data: TData | null;
+    // (undocumented)
+    errors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    extensions?: TExtensions;
+    // (undocumented)
+    label?: string;
+    // (undocumented)
+    path: Path;
+}
+
+// @public (undocumented)
+export class InMemoryCache extends ApolloCache<NormalizedCacheObject> {
+    constructor(config?: InMemoryCacheConfig);
+    // (undocumented)
+    readonly assumeImmutableResults = true;
+    // (undocumented)
+    batch<TUpdateResult>(options: Cache_2.BatchOptions<InMemoryCache, TUpdateResult>): TUpdateResult;
+    // Warning: (ae-forgotten-export) The symbol "BroadcastOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected broadcastWatches(options?: BroadcastOptions): void;
+    // (undocumented)
+    protected config: InMemoryCacheConfig;
+    // (undocumented)
+    diff<TData, TVariables extends OperationVariables = any>(options: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
+    // (undocumented)
+    evict(options: Cache_2.EvictOptions): boolean;
+    // (undocumented)
+    extract(optimistic?: boolean): NormalizedCacheObject;
+    // (undocumented)
+    gc(options?: {
+        resetResultCache?: boolean;
+        resetResultIdentities?: boolean;
+    }): string[];
+    // (undocumented)
+    identify(object: StoreObject | Reference): string | undefined;
+    // (undocumented)
+    readonly makeVar: typeof makeVar;
+    // (undocumented)
+    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
+    // (undocumented)
+    performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any;
+    // (undocumented)
+    readonly policies: Policies;
+    // (undocumented)
+    read<T>(options: Cache_2.ReadOptions): T | null;
+    // (undocumented)
+    release(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    removeOptimistic(idToRemove: string): void;
+    // (undocumented)
+    reset(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    restore(data: NormalizedCacheObject): this;
+    // (undocumented)
+    retain(rootId: string, optimistic?: boolean): number;
+    // (undocumented)
+    transformDocument(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
+    // (undocumented)
+    write(options: Cache_2.WriteOptions): Reference | undefined;
+}
+
+// @public (undocumented)
+export interface InMemoryCacheConfig extends ApolloReducerConfig {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FragmentRegistryAPI" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fragments?: FragmentRegistryAPI;
+    // (undocumented)
+    possibleTypes?: PossibleTypesMap;
+    // (undocumented)
+    resultCacheMaxSize?: number;
+    // (undocumented)
+    resultCaching?: boolean;
+    // (undocumented)
+    typePolicies?: TypePolicies;
+}
+
+// @public (undocumented)
+class InternalQueryReference<TData = unknown> {
+    // Warning: (ae-forgotten-export) The symbol "InternalQueryReferenceOptions" needs to be exported by the entry point index.d.ts
+    constructor(observable: ObservableQuery<TData>, options: InternalQueryReferenceOptions);
+    // (undocumented)
+    applyOptions(watchQueryOptions: ObservedOptions): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "ObservedOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    didChangeOptions(watchQueryOptions: ObservedOptions): boolean;
+    // Warning: (ae-forgotten-export) The symbol "FetchMoreOptions_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchMore(options: FetchMoreOptions_2<TData>): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "CacheKey" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly key: CacheKey;
+    // Warning: (ae-forgotten-export) The symbol "Listener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    listen(listener: Listener<TData>): () => void;
+    // (undocumented)
+    readonly observable: ObservableQuery<TData>;
+    // (undocumented)
+    promise: Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    promiseCache?: Map<CacheKey, Promise<ApolloQueryResult<TData>>>;
+    // (undocumented)
+    refetch(variables: OperationVariables | undefined): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    result: ApolloQueryResult<TData>;
+    // (undocumented)
+    retain(): () => void;
+    // (undocumented)
+    get watchQueryOptions(): WatchQueryOptions<OperationVariables, TData>;
+}
+
+// @public (undocumented)
+interface InternalQueryReferenceOptions {
+    // (undocumented)
+    autoDisposeTimeoutMs?: number;
+    // (undocumented)
+    key: CacheKey;
+    // (undocumented)
+    onDispose?: () => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+export type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+
+// @public (undocumented)
+export interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+    // (undocumented)
+    include?: InternalRefetchQueriesInclude;
+    // (undocumented)
+    removeOptimistic?: string;
+}
+
+// @public (undocumented)
+export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
+
+// @public (undocumented)
+export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+
+// @public (undocumented)
+interface InvalidateModifier {
+    // (undocumented)
+    [_invalidateModifier]: true;
+}
+
+// @public (undocumented)
+const _invalidateModifier: unique symbol;
+
+// @public (undocumented)
+export function isApolloError(err: Error): err is ApolloError;
+
+// @public (undocumented)
+export function isNetworkRequestSettled(networkStatus?: NetworkStatus): boolean;
+
+// @public (undocumented)
+export function isReference(obj: any): obj is Reference;
+
+// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;
+
+// @public (undocumented)
+type KeyArgsFunction = (args: Record<string, any> | null, context: {
+    typename: string;
+    fieldName: string;
+    field: FieldNode | null;
+    variables?: Record<string, any>;
+}) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeyFieldsContext = {
+    typename: string | undefined;
+    storeObject: StoreObject;
+    readField: ReadFieldFunction;
+    selectionSet?: SelectionSetNode;
+    fragmentMap?: FragmentMap;
+    keyObject?: Record<string, any>;
+};
+
+// @public (undocumented)
+type KeyFieldsFunction = (object: Readonly<StoreObject>, context: KeyFieldsContext) => KeySpecifier | false | ReturnType<IdGetter>;
+
+// @public (undocumented)
+type KeySpecifier = ReadonlyArray<string | KeySpecifier>;
+
+// @public (undocumented)
+class Layer extends EntityStore {
+    constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup);
+    // (undocumented)
+    addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
+    // (undocumented)
+    findChildRefIds(dataId: string): Record<string, true>;
+    // (undocumented)
+    getStorage(): StorageType;
+    // (undocumented)
+    readonly group: CacheGroup;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly parent: EntityStore;
+    // (undocumented)
+    removeLayer(layerId: string): EntityStore;
+    // (undocumented)
+    readonly replay: (layer: EntityStore) => any;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+}
+
+// @public (undocumented)
+export type LazyQueryExecFunction<TData, TVariables extends OperationVariables> = (options?: Partial<LazyQueryHookExecOptions<TData, TVariables>>) => Promise<QueryResult<TData, TVariables>>;
+
+// @public (undocumented)
+export interface LazyQueryHookExecOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends LazyQueryHookOptions<TData, TVariables> {
+    // (undocumented)
+    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface LazyQueryHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends Omit<QueryHookOptions<TData, TVariables>, "skip"> {
+}
+
+// @public (undocumented)
+export type LazyQueryResult<TData, TVariables extends OperationVariables> = QueryResult<TData, TVariables>;
+
+// @public (undocumented)
+export type LazyQueryResultTuple<TData, TVariables extends OperationVariables> = [LazyQueryExecFunction<TData, TVariables>, QueryResult<TData, TVariables>];
+
+// @public (undocumented)
+type Listener<TData> = (promise: Promise<ApolloQueryResult<TData>>) => void;
+
+// @public (undocumented)
+class LocalState<TCacheShape> {
+    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    // (undocumented)
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    // (undocumented)
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    getFragmentMatcher(): FragmentMatcher;
+    // (undocumented)
+    getResolvers(): Resolvers;
+    // (undocumented)
+    prepareContext(context?: Record<string, any>): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey(obj: StoreObject): string | undefined;
+    };
+    // (undocumented)
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    // (undocumented)
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    // (undocumented)
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    // (undocumented)
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    // (undocumented)
+    shouldForceResolvers(document: ASTNode): boolean;
+}
+
+// @public (undocumented)
+type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+
+// @public (undocumented)
+export function makeReference(id: string): Reference;
+
+// @public (undocumented)
+export function makeVar<T>(value: T): ReactiveVar<T>;
+
+// @public (undocumented)
+type MaybeAsync<T> = T | PromiseLike<T>;
+
+// @public (undocumented)
+export interface MergeInfo {
+    // (undocumented)
+    field: FieldNode;
+    // (undocumented)
+    merge: FieldMergeFunction;
+    // (undocumented)
+    typename: string | undefined;
+}
+
+// @public (undocumented)
+type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;
+
+// Warning: (ae-forgotten-export) The symbol "OptionsUnion" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function mergeOptions<TDefaultOptions extends Partial<OptionsUnion<any, any, any>>, TOptions extends TDefaultOptions>(defaults: TDefaultOptions | Partial<TDefaultOptions> | undefined, options: TOptions | Partial<TOptions>): TOptions & TDefaultOptions;
+
+// @public (undocumented)
+export interface MergeTree {
+    // (undocumented)
+    info?: MergeInfo;
+    // (undocumented)
+    map: Map<string | number, MergeTree>;
+}
+
+// @public (undocumented)
+export type MethodKeys<T> = {
+    [P in keyof T]: T[P] extends Function ? P : never;
+}[keyof T];
+
+// @public (undocumented)
+export class MissingFieldError extends Error {
+    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly missing: MissingTree;
+    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly path: MissingTree | Array<string | number>;
+    // (undocumented)
+    readonly query: DocumentNode;
+    // (undocumented)
+    readonly variables?: Record<string, any> | undefined;
+}
+
+// @public (undocumented)
+type MissingTree = string | {
+    readonly [key: string]: MissingTree;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
+
+// @public (undocumented)
+type ModifierDetails = {
+    DELETE: DeleteModifier;
+    INVALIDATE: InvalidateModifier;
+    fieldName: string;
+    storeFieldName: string;
+    readField: ReadFieldFunction;
+    canRead: CanReadFunction;
+    isReference: typeof isReference;
+    toReference: ToReferenceFunction;
+    storage: StorageType;
+};
+
+// @public (undocumented)
+type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
+    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
+}>;
+
+// @public (undocumented)
+interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
+    // (undocumented)
+    awaitRefetchQueries?: boolean;
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<any>;
+    // (undocumented)
+    optimisticResponse?: TData | ((vars: TVariables) => TData);
+    // (undocumented)
+    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    // (undocumented)
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    // (undocumented)
+    updateQueries?: MutationQueryReducersMap<TData>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface MutationDataOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+
+// @public (undocumented)
+export type MutationFunction<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = (options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>;
+
+// @public (undocumented)
+export interface MutationFunctionOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+    // (undocumented)
+    mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface MutationHookOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {
+}
+
+// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    // Warning: (ae-forgotten-export) The symbol "MutationFetchPolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    fetchPolicy?: MutationFetchPolicy;
+    // (undocumented)
+    keepRootFields?: boolean;
+    // (undocumented)
+    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+
+// @public (undocumented)
+export type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+
+// @public (undocumented)
+export interface MutationResult<TData = any> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data?: TData | null;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    reset(): void;
+}
+
+// @public (undocumented)
+interface MutationStoreValue {
+    // (undocumented)
+    error: Error | null;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    mutation: DocumentNode;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export type MutationTuple<TData, TVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = [
+(options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>,
+MutationResult<TData>
+];
+
+// @public (undocumented)
+export type MutationUpdaterFn<T = {
+    [key: string]: any;
+}> = (cache: ApolloCache<T>, mutationResult: FetchResult<T>) => void;
+
+// @public (undocumented)
+export type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
+    context?: TContext;
+    variables?: TVariables;
+}) => void;
+
+// @public (undocumented)
+export enum NetworkStatus {
+    // (undocumented)
+    error = 8,
+    // (undocumented)
+    fetchMore = 3,
+    // (undocumented)
+    loading = 1,
+    // (undocumented)
+    poll = 6,
+    // (undocumented)
+    ready = 7,
+    // (undocumented)
+    refetch = 4,
+    // (undocumented)
+    setVariables = 2
+}
+
+// @public (undocumented)
+interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    // (undocumented)
+    initialFetchPolicy: WatchQueryFetchPolicy;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    reason: "after-fetch" | "variables-changed";
+}
+
+// @public (undocumented)
+export type NextLink = (operation: Operation) => Observable<FetchResult>;
+
+// @public (undocumented)
+type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;
+
+// @public (undocumented)
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+
+// @public (undocumented)
+export interface NormalizedCache {
+    // (undocumented)
+    canRead: CanReadFunction;
+    // (undocumented)
+    clear(): void;
+    // (undocumented)
+    delete(dataId: string, fieldName?: string): boolean;
+    // (undocumented)
+    get(dataId: string, fieldName: string): StoreValue;
+    // Warning: (ae-forgotten-export) The symbol "FieldValueGetter" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getFieldValue: FieldValueGetter;
+    // (undocumented)
+    getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
+    // (undocumented)
+    has(dataId: string): boolean;
+    // (undocumented)
+    merge(olderId: string, newerObject: StoreObject): void;
+    // (undocumented)
+    merge(olderObject: StoreObject, newerId: string): void;
+    // (undocumented)
+    modify<Entity extends Record<string, any>>(dataId: string, fields: Modifiers<Entity> | AllFieldsModifier<Entity>): boolean;
+    // (undocumented)
+    release(rootId: string): number;
+    // (undocumented)
+    replace(newData: NormalizedCacheObject): void;
+    // (undocumented)
+    retain(rootId: string): number;
+    // (undocumented)
+    toObject(): NormalizedCacheObject;
+    // (undocumented)
+    toReference: ToReferenceFunction;
+}
+
+// @public (undocumented)
+export interface NormalizedCacheObject {
+    // (undocumented)
+    [dataId: string]: StoreObject | undefined;
+    // (undocumented)
+    __META?: {
+        extraRootIds: string[];
+    };
+}
+
+export { Observable }
+
+// @public (undocumented)
+export class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    constructor({ queryManager, queryInfo, options, }: {
+        queryManager: QueryManager<any>;
+        queryInfo: QueryInfo;
+        options: WatchQueryOptions<TVariables, TData>;
+    });
+    // (undocumented)
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: (previousQueryResult: TData, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => TData;
+    }): Promise<ApolloQueryResult<TFetchData>>;
+    // (undocumented)
+    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
+    // (undocumented)
+    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
+    // (undocumented)
+    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
+    // (undocumented)
+    hasObservers(): boolean;
+    // (undocumented)
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
+    // (undocumented)
+    readonly options: WatchQueryOptions<TVariables, TData>;
+    // (undocumented)
+    get query(): TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    readonly queryName?: string;
+    // (undocumented)
+    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
+    // (undocumented)
+    resetLastResults(): void;
+    // (undocumented)
+    resetQueryStoreErrors(): void;
+    // (undocumented)
+    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): ObservableSubscription;
+    // (undocumented)
+    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): ObservableSubscription;
+    // (undocumented)
+    result(): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
+    // (undocumented)
+    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    // (undocumented)
+    startPolling(pollInterval: number): void;
+    // (undocumented)
+    stopPolling(): void;
+    // (undocumented)
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    // (undocumented)
+    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
+    // (undocumented)
+    get variables(): TVariables | undefined;
+}
+
+// @public (undocumented)
+export type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<ObservableQuery<TData, TVariables>, "startPolling" | "stopPolling" | "subscribeToMore" | "updateQuery" | "refetch" | "reobserve" | "variables" | "fetchMore">;
+
+export { ObservableSubscription }
+
+// @public (undocumented)
+const OBSERVED_CHANGED_OPTIONS: readonly ["canonizeResults", "context", "errorPolicy", "fetchPolicy", "refetchWritePolicy", "returnPartialData"];
+
+// Warning: (ae-forgotten-export) The symbol "OBSERVED_CHANGED_OPTIONS" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+type ObservedOptions = Pick<WatchQueryOptions, (typeof OBSERVED_CHANGED_OPTIONS)[number]>;
+
+export { Observer }
+
+// @public (undocumented)
+export interface OnDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    data: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+export type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
+
+// @public (undocumented)
+export interface OnSubscriptionDataOptions<TData = any> {
+    // (undocumented)
+    client: ApolloClient<object>;
+    // (undocumented)
+    subscriptionData: SubscriptionResult<TData>;
+}
+
+// @public (undocumented)
+export interface Operation {
+    // (undocumented)
+    extensions: Record<string, any>;
+    // (undocumented)
+    getContext: () => DefaultContext;
+    // (undocumented)
+    operationName: string;
+    // (undocumented)
+    query: DocumentNode;
+    // (undocumented)
+    setContext: (context: DefaultContext) => DefaultContext;
+    // (undocumented)
+    variables: Record<string, any>;
+}
+
+// @public (undocumented)
+export function operationName(type: DocumentType_2): string;
+
+// @public (undocumented)
+export type OperationVariables = Record<string, any>;
+
+// @public (undocumented)
+export type OptimisticStoreItem = {
+    id: string;
+    data: NormalizedCacheObject;
+    transaction: Transaction<NormalizedCacheObject>;
+};
+
+// @public (undocumented)
+type OptionsUnion<TData, TVariables extends OperationVariables, TContext> = WatchQueryOptions<TVariables, TData> | QueryOptions<TVariables, TData> | MutationOptions<TData, TVariables, TContext>;
+
+// @public (undocumented)
+export function parseAndCheckHttpResponse(operations: Operation | Operation[]): (response: Response) => Promise<any>;
+
+// @public (undocumented)
+export function parser(document: DocumentNode): IDocumentDefinition;
+
+// @public (undocumented)
+export type Path = ReadonlyArray<string | number>;
+
+// @public (undocumented)
+class Policies {
+    constructor(config: {
+        cache: InMemoryCache;
+        dataIdFromObject?: KeyFieldsFunction;
+        possibleTypes?: PossibleTypesMap;
+        typePolicies?: TypePolicies;
+    });
+    // (undocumented)
+    addPossibleTypes(possibleTypes: PossibleTypesMap): void;
+    // (undocumented)
+    addTypePolicies(typePolicies: TypePolicies): void;
+    // (undocumented)
+    readonly cache: InMemoryCache;
+    // (undocumented)
+    fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string | undefined, result?: Record<string, any>, variables?: Record<string, any>): boolean;
+    // (undocumented)
+    getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
+    // (undocumented)
+    getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
+    // Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getStoreFieldName(fieldSpec: FieldSpecifier): string;
+    // (undocumented)
+    hasKeyArgs(typename: string | undefined, fieldName: string): boolean;
+    // (undocumented)
+    identify(object: StoreObject, partialContext?: Partial<KeyFieldsContext>): [string?, StoreObject?];
+    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
+    // (undocumented)
+    readonly rootIdsByTypename: Record<string, string>;
+    // (undocumented)
+    readonly rootTypenamesById: Record<string, string>;
+    // (undocumented)
+    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
+    // (undocumented)
+    readonly usingPossibleTypes = false;
+}
+
+// @public (undocumented)
+export type PossibleTypesMap = {
+    [supertype: string]: string[];
+};
+
+// @public (undocumented)
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+
+// @public (undocumented)
+const print_2: typeof print_3;
+
+// @public (undocumented)
+interface Printer {
+    // Warning: (ae-forgotten-export) The symbol "print_2" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    (node: ASTNode, originalPrint: typeof print_2): string;
+}
+
+// @public (undocumented)
+const QUERY_REFERENCE_SYMBOL: unique symbol;
+
+// @public (undocumented)
+interface QueryData {
+    // (undocumented)
+    fetchData(): Promise<void>;
+    // (undocumented)
+    getOptions(): any;
+}
+
+// @public (undocumented)
+export interface QueryDataOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+    // (undocumented)
+    children?: (result: QueryResult<TData, TVariables>) => ReactNode;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface QueryFunctionOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {
+    // (undocumented)
+    defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
+    // (undocumented)
+    onCompleted?: (data: TData) => void;
+    // (undocumented)
+    onError?: (error: ApolloError) => void;
+    // (undocumented)
+    skip?: boolean;
+}
+
+// @public (undocumented)
+export interface QueryHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {
+}
+
+// @public (undocumented)
+class QueryInfo {
+    constructor(queryManager: QueryManager<any>, queryId?: string);
+    // (undocumented)
+    document: DocumentNode | null;
+    // (undocumented)
+    getDiff(): Cache_2.DiffResult<any>;
+    // (undocumented)
+    graphQLErrors?: ReadonlyArray<GraphQLError>;
+    // (undocumented)
+    init(query: {
+        document: DocumentNode;
+        variables: Record<string, any> | undefined;
+        networkStatus?: NetworkStatus;
+        observableQuery?: ObservableQuery<any>;
+        lastRequestId?: number;
+    }): this;
+    // (undocumented)
+    lastRequestId: number;
+    // (undocumented)
+    listeners: Set<QueryListener>;
+    // (undocumented)
+    markError(error: ApolloError): ApolloError;
+    // (undocumented)
+    markReady(): NetworkStatus;
+    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
+    // (undocumented)
+    networkError?: Error | null;
+    // (undocumented)
+    networkStatus?: NetworkStatus;
+    // (undocumented)
+    notify(): void;
+    // (undocumented)
+    readonly observableQuery: ObservableQuery<any> | null;
+    // (undocumented)
+    readonly queryId: string;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    resetLastWrite(): void;
+    // (undocumented)
+    setDiff(diff: Cache_2.DiffResult<any> | null): void;
+    // (undocumented)
+    setObservableQuery(oq: ObservableQuery<any> | null): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopped: boolean;
+    // (undocumented)
+    subscriptions: Set<ObservableSubscription>;
+    // (undocumented)
+    variables?: Record<string, any>;
+}
+
+// @public (undocumented)
+export interface QueryLazyOptions<TVariables> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export type QueryListener = (queryInfo: QueryInfo) => void;
+
+// @public (undocumented)
+class QueryManager<TStore> {
+    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        cache: ApolloCache<TStore>;
+        link: ApolloLink;
+        defaultOptions?: DefaultOptions;
+        documentTransform?: DocumentTransform;
+        queryDeduplication?: boolean;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    // (undocumented)
+    readonly assumeImmutableResults: boolean;
+    // (undocumented)
+    broadcastQueries(): void;
+    // (undocumented)
+    cache: ApolloCache<TStore>;
+    // (undocumented)
+    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
+    // (undocumented)
+    defaultOptions: DefaultOptions;
+    // (undocumented)
+    readonly documentTransform: DocumentTransform;
+    // (undocumented)
+    protected fetchCancelFns: Map<string, (error: any) => any>;
+    // (undocumented)
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    generateMutationId(): string;
+    // (undocumented)
+    generateQueryId(): string;
+    // (undocumented)
+    generateRequestId(): number;
+    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
+    // (undocumented)
+    getLocalState(): LocalState<TStore>;
+    // (undocumented)
+    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
+    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    getQueryStore(): Record<string, QueryStoreValue>;
+    // (undocumented)
+    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
+    // (undocumented)
+    link: ApolloLink;
+    // (undocumented)
+    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+        mutationId: string;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        keepRootFields?: boolean;
+    }): void;
+    // (undocumented)
+    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+        mutationId: string;
+        result: FetchResult<TData>;
+        document: DocumentNode;
+        variables?: TVariables;
+        fetchPolicy?: MutationFetchPolicy;
+        errorPolicy: ErrorPolicy;
+        context?: TContext;
+        updateQueries: UpdateQueries<TData>;
+        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+        awaitRefetchQueries?: boolean;
+        refetchQueries?: InternalRefetchQueriesInclude;
+        removeOptimistic?: string;
+        onQueryUpdated?: OnQueryUpdated<any>;
+        keepRootFields?: boolean;
+    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
+    // (undocumented)
+    mutationStore?: {
+        [mutationId: string]: MutationStoreValue;
+    };
+    // (undocumented)
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
+    // (undocumented)
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    // (undocumented)
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    // (undocumented)
+    removeQuery(queryId: string): void;
+    // (undocumented)
+    resetErrors(queryId: string): void;
+    // (undocumented)
+    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
+    // (undocumented)
+    readonly ssrMode: boolean;
+    // (undocumented)
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    stopQuery(queryId: string): void;
+    // (undocumented)
+    stopQueryInStore(queryId: string): void;
+    // (undocumented)
+    transform(document: DocumentNode): DocumentNode;
+    // (undocumented)
+    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+}
+
+// @public (undocumented)
+interface QueryOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    canonizeResults?: boolean;
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    notifyOnNetworkStatusChange?: boolean;
+    // (undocumented)
+    partialRefetch?: boolean;
+    // (undocumented)
+    pollInterval?: number;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    returnPartialData?: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+export { QueryOptions as PureQueryOptions }
+export { QueryOptions }
+
+// @public (undocumented)
+export interface QueryReference<TData = unknown> {
+    // Warning: (ae-forgotten-export) The symbol "InternalQueryReference" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    [QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData>;
+}
+
+// @public (undocumented)
+export interface QueryResult<TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {
+    // (undocumented)
+    called: boolean;
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData | undefined;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    observable: ObservableQuery<TData, TVariables>;
+    // (undocumented)
+    previousData?: TData;
+}
+
+// @public (undocumented)
+type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+
+// @public (undocumented)
+export type QueryTuple<TData, TVariables extends OperationVariables> = LazyQueryResultTuple<TData, TVariables>;
+
+// @public (undocumented)
+type ReactiveListener<T> = (value: T) => any;
+
+// @public (undocumented)
+export interface ReactiveVar<T> {
+    // (undocumented)
+    (newValue?: T): T;
+    // (undocumented)
+    attachCache(cache: ApolloCache<any>): this;
+    // (undocumented)
+    forgetCache(cache: ApolloCache<any>): boolean;
+    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    onNextChange(listener: ReactiveListener<T>): () => void;
+}
+
+// @public (undocumented)
+interface ReadFieldFunction {
+    // (undocumented)
+    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
+    // (undocumented)
+    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
+}
+
+// @public (undocumented)
+interface ReadFieldOptions extends FieldSpecifier {
+    // (undocumented)
+    from?: StoreObject | Reference;
+}
+
+// @public (undocumented)
+export interface ReadMergeModifyContext {
+    // (undocumented)
+    store: NormalizedCache;
+    // (undocumented)
+    variables?: Record<string, any>;
+    // (undocumented)
+    varString?: string;
+}
+
+// @public (undocumented)
+export type ReadQueryOptions = {
+    store: NormalizedCache;
+    query: DocumentNode;
+    variables?: Object;
+    previousResult?: any;
+    canonizeResults?: boolean;
+    rootId?: string;
+    config?: ApolloReducerConfig;
+};
+
+// @public (undocumented)
+export interface Reference {
+    // (undocumented)
+    readonly __ref: string;
+}
+
+// @public (undocumented)
+type RefetchFunction<TData, TVariables extends OperationVariables> = ObservableQueryFields<TData, TVariables>["refetch"];
+
+// @public (undocumented)
+export type RefetchQueriesFunction = (...args: any[]) => InternalRefetchQueriesInclude;
+
+// @public (undocumented)
+export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+
+// @public (undocumented)
+type RefetchQueriesIncludeShorthand = "all" | "active";
+
+// @public (undocumented)
+export interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
+    // (undocumented)
+    include?: RefetchQueriesInclude;
+    // (undocumented)
+    onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    // (undocumented)
+    optimistic?: boolean;
+    // (undocumented)
+    updateCache?: (cache: TCache) => void;
+}
+
+// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+
+// @public (undocumented)
+export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
+    // (undocumented)
+    queries: ObservableQuery<any>[];
+    // (undocumented)
+    results: InternalRefetchQueriesResult<TResult>[];
+}
+
+// @public (undocumented)
+export type RefetchQueryDescriptor = string | DocumentNode;
+
+// @public (undocumented)
+type RefetchWritePolicy = "merge" | "overwrite";
+
+// @public (undocumented)
+class RenderPromises {
+    // (undocumented)
+    addObservableQueryPromise<TData, TVariables extends OperationVariables>(obsQuery: ObservableQuery<TData, TVariables>): ReactNode;
+    // Warning: (ae-forgotten-export) The symbol "QueryData" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    addQueryPromise(queryInstance: QueryData, finish?: () => React.ReactNode): React.ReactNode;
+    // (undocumented)
+    consumeAndAwaitPromises(): Promise<any[]>;
+    // (undocumented)
+    getSSRObservable<TData, TVariables extends OperationVariables>(props: QueryDataOptions<TData, TVariables>): ObservableQuery<any, TVariables> | null;
+    // (undocumented)
+    hasPromises(): boolean;
+    // (undocumented)
+    registerSSRObservable<TData, TVariables extends OperationVariables>(observable: ObservableQuery<any, TVariables>): void;
+    // (undocumented)
+    stop(): void;
+}
+
+// @public (undocumented)
+export type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
+
+// @public (undocumented)
+export const resetApolloContext: typeof getApolloContext;
+
+export { resetCaches }
+
+// @public (undocumented)
+export type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+
+// @public (undocumented)
+export interface Resolvers {
+    // (undocumented)
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+
+// Warning: (ae-forgotten-export) The symbol "Body_2" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function rewriteURIForGET(chosenURI: string, body: Body_2): {
+    parseError: any;
+    newURI?: undefined;
+} | {
+    newURI: string;
+    parseError?: undefined;
+};
+
+// @public (undocumented)
+type SafeReadonly<T> = T extends object ? Readonly<T> : T;
+
+// Warning: (ae-forgotten-export) The symbol "HttpConfig" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function selectHttpOptionsAndBody(operation: Operation, fallbackConfig: HttpConfig, ...configs: Array<HttpConfig>): {
+    options: HttpConfig & Record<string, any>;
+    body: Body_2;
+};
+
+// @public (undocumented)
+export function selectHttpOptionsAndBodyInternal(operation: Operation, printer: Printer, ...configs: HttpConfig[]): {
+    options: HttpConfig & Record<string, any>;
+    body: Body_2;
+};
+
+// @public (undocumented)
+export const selectURI: (operation: Operation, fallbackURI?: string | ((operation: Operation) => string) | undefined) => any;
+
+// @public (undocumented)
+export const serializeFetchParameter: (p: any, label: string) => string;
+
+// @public (undocumented)
+export type ServerError = Error & {
+    response: Response;
+    result: Record<string, any> | string;
+    statusCode: number;
+};
+
+// @public (undocumented)
+export type ServerParseError = Error & {
+    response: Response;
+    statusCode: number;
+    bodyText: string;
+};
+
+export { setLogVerbosity }
+
+// @public (undocumented)
+export interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
+    // (undocumented)
+    context?: TContext;
+    // (undocumented)
+    data?: TData | null;
+}
+
+// @public (undocumented)
+export type SkipToken = typeof skipToken;
+
+// @public (undocumented)
+export const skipToken: unique symbol;
+
+// @public (undocumented)
+type Source<T> = MaybeAsync<Observable<T>>;
+
+// @public (undocumented)
+export const split: typeof ApolloLink.split;
+
+// @public (undocumented)
+type StorageType = Record<string, any>;
+
+// @public (undocumented)
+export interface StoreObject {
+    // (undocumented)
+    [storeFieldName: string]: StoreValue;
+    // (undocumented)
+    __typename?: string;
+}
+
+// @public (undocumented)
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Record<string, any>[] ? Readonly<StoreVal> | readonly Reference[] : StoreVal extends Record<string, any> ? StoreVal | Reference : StoreVal;
+
+// @public (undocumented)
+export type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
+
+// @public (undocumented)
+class Stump extends Layer {
+    constructor(root: EntityStore.Root);
+    // (undocumented)
+    merge(): any;
+    // (undocumented)
+    removeLayer(): this;
+}
+
+// @public (undocumented)
+type SubscribeToMoreFunction<TData, TVariables extends OperationVariables> = ObservableQueryFields<TData, TVariables>["subscribeToMore"];
+
+// @public (undocumented)
+export type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+    context?: DefaultContext;
+};
+
+// @public (undocumented)
+export interface SubscriptionCurrentObservable {
+    // (undocumented)
+    query?: Observable<any>;
+    // (undocumented)
+    subscription?: ObservableSubscription;
+}
+
+// @public (undocumented)
+export interface SubscriptionDataOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {
+    // (undocumented)
+    children?: null | ((result: SubscriptionResult<TData>) => JSX.Element | null);
+    // (undocumented)
+    subscription: DocumentNode | TypedDocumentNode<TData, TVariables>;
+}
+
+// @public (undocumented)
+export interface SubscriptionHookOptions<TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {
+}
+
+// @public (undocumented)
+export interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
+    // (undocumented)
+    context?: DefaultContext;
+    // (undocumented)
+    errorPolicy?: ErrorPolicy;
+    // (undocumented)
+    fetchPolicy?: FetchPolicy;
+    // (undocumented)
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface SubscriptionResult<TData = any, TVariables = any> {
+    // (undocumented)
+    data?: TData;
+    // (undocumented)
+    error?: ApolloError;
+    // (undocumented)
+    loading: boolean;
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// Warning: (ae-forgotten-export) The symbol "SuspenseCache_2" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export class SuspenseCache extends SuspenseCache_2 {
+    constructor();
+}
+
+// @public (undocumented)
+class SuspenseCache_2 {
+    // Warning: (ae-forgotten-export) The symbol "SuspenseCacheOptions" needs to be exported by the entry point index.d.ts
+    constructor(options?: SuspenseCacheOptions);
+    // (undocumented)
+    getQueryRef<TData = any>(cacheKey: CacheKey, createObservable: () => ObservableQuery<TData>): InternalQueryReference<TData>;
+}
+
+// @public (undocumented)
+interface SuspenseCacheOptions {
+    // (undocumented)
+    autoDisposeTimeoutMs?: number;
+}
+
+// @public (undocumented)
+export type SuspenseQueryHookFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
+
+// @public (undocumented)
+export interface SuspenseQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick<QueryHookOptions<TData, TVariables>, "client" | "variables" | "errorPolicy" | "context" | "canonizeResults" | "returnPartialData" | "refetchWritePolicy"> {
+    // (undocumented)
+    fetchPolicy?: SuspenseQueryHookFetchPolicy;
+    // (undocumented)
+    queryKey?: string | number | any[];
+    // (undocumented)
+    skip?: boolean;
+    // (undocumented)
+    suspenseCache?: SuspenseCache;
+}
+
+// @public (undocumented)
+export const throwServerError: (response: Response, result: any, message: string) => never;
+
+// @public (undocumented)
+export function toPromise<R>(observable: Observable<R>): Promise<R>;
+
+// @public (undocumented)
+type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
+
+// @public (undocumented)
+export type Transaction<T> = (c: ApolloCache<T>) => void;
+
+// @public (undocumented)
+interface TransformCacheEntry {
+    // (undocumented)
+    asQuery: DocumentNode;
+    // (undocumented)
+    clientQuery: DocumentNode | null;
+    // (undocumented)
+    defaultVars: OperationVariables;
+    // (undocumented)
+    hasClientExports: boolean;
+    // (undocumented)
+    hasForcedResolvers: boolean;
+    // (undocumented)
+    hasNonreactiveDirective: boolean;
+    // (undocumented)
+    serverQuery: DocumentNode | null;
+}
+
+// @public (undocumented)
+type TransformFn = (document: DocumentNode) => DocumentNode;
+
+export { TypedDocumentNode }
+
+// @public (undocumented)
+export type TypePolicies = {
+    [__typename: string]: TypePolicy;
+};
+
+// @public (undocumented)
+export type TypePolicy = {
+    keyFields?: KeySpecifier | KeyFieldsFunction | false;
+    merge?: FieldMergeFunction | boolean;
+    queryType?: true;
+    mutationType?: true;
+    subscriptionType?: true;
+    fields?: {
+        [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
+    };
+};
+
+// @public (undocumented)
+type UnionForAny<T> = T extends never ? "a" : 1;
+
+// @public (undocumented)
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// @public (undocumented)
+type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
+
+// @public (undocumented)
+type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+
+// @public (undocumented)
+export interface UpdateQueryOptions<TVariables> {
+    // (undocumented)
+    variables?: TVariables;
+}
+
+// @public (undocumented)
+export interface UriFunction {
+    // (undocumented)
+    (operation: Operation): string;
+}
+
+// @public (undocumented)
+export function useApolloClient(override?: ApolloClient<object>): ApolloClient<object>;
+
+// Warning: (ae-forgotten-export) The symbol "BackgroundQueryHookOptionsNoInfer" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function useBackgroundQuery<TData, TVariables extends OperationVariables, TOptions extends Omit<BackgroundQueryHookOptions<TData>, "variables">>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & TOptions): [
+(QueryReference<TOptions["errorPolicy"] extends "ignore" | "all" ? TOptions["returnPartialData"] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions["returnPartialData"] extends true ? DeepPartial<TData> : TData> | (TOptions["skip"] extends boolean ? undefined : never)),
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+    errorPolicy: "ignore" | "all";
+}): [
+QueryReference<DeepPartial<TData> | undefined>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    errorPolicy: "ignore" | "all";
+}): [
+QueryReference<TData | undefined>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    skip: boolean;
+    returnPartialData: true;
+}): [
+QueryReference<DeepPartial<TData>> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+}): [
+QueryReference<DeepPartial<TData>>,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    skip: boolean;
+}): [
+QueryReference<TData> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables>): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): [undefined, UseBackgroundQueryResult<TData, TVariables>];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
+    returnPartialData: true;
+})): [
+QueryReference<DeepPartial<TData>> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SkipToken | BackgroundQueryHookOptionsNoInfer<TData, TVariables>): [
+QueryReference<TData> | undefined,
+UseBackgroundQueryResult<TData, TVariables>
+];
+
+// @public (undocumented)
+export type UseBackgroundQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+    fetchMore: FetchMoreFunction<TData, TVariables>;
+    refetch: RefetchFunction<TData, TVariables>;
+};
+
+// @public (undocumented)
+export function useFragment<TData = any, TVars = OperationVariables>(options: UseFragmentOptions<TData, TVars>): UseFragmentResult<TData>;
+
+// @public (undocumented)
+export interface UseFragmentOptions<TData, TVars> extends Omit<Cache_2.DiffOptions<NoInfer<TData>, NoInfer<TVars>>, "id" | "query" | "optimistic" | "previousResult" | "returnPartialData">, Omit<Cache_2.ReadFragmentOptions<TData, TVars>, "id" | "variables" | "returnPartialData"> {
+    // (undocumented)
+    from: StoreObject | Reference | string;
+    // (undocumented)
+    optimistic?: boolean;
+}
+
+// @public (undocumented)
+export type UseFragmentResult<TData> = {
+    data: TData;
+    complete: true;
+    missing?: never;
+} | {
+    data: DeepPartial<TData>;
+    complete: false;
+    missing?: MissingTree;
+};
+
+// @public (undocumented)
+export function useLazyQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: LazyQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): LazyQueryResultTuple<TData, TVariables>;
+
+// @public (undocumented)
+export function useMutation<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: MutationHookOptions<NoInfer<TData>, NoInfer<TVariables>, TContext, TCache>): MutationTuple<TData, TVariables, TContext, TCache>;
+
+// @public (undocumented)
+export function useQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: QueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): QueryResult<TData, TVariables>;
+
+// @public (undocumented)
+export function useReactiveVar<T>(rv: ReactiveVar<T>): T;
+
+// @public (undocumented)
+export function useReadQuery<TData>(queryRef: QueryReference<TData>): {
+    data: TData;
+    networkStatus: NetworkStatus;
+    error: ApolloError | undefined;
+};
+
+// @public (undocumented)
+export function useSubscription<TData = any, TVariables extends OperationVariables = OperationVariables>(subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SubscriptionHookOptions<NoInfer<TData>, NoInfer<TVariables>>): SubscriptionResult<TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData, TVariables extends OperationVariables, TOptions extends Omit<SuspenseQueryHookOptions<TData>, "variables">>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & TOptions): UseSuspenseQueryResult<TOptions["errorPolicy"] extends "ignore" | "all" ? TOptions["returnPartialData"] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions["returnPartialData"] extends true ? TOptions["skip"] extends boolean ? DeepPartial<TData> | undefined : DeepPartial<TData> : TOptions["skip"] extends boolean ? TData | undefined : TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+    errorPolicy: "ignore" | "all";
+}): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    errorPolicy: "ignore" | "all";
+}): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    skip: boolean;
+    returnPartialData: true;
+}): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+}): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    skip: boolean;
+}): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): UseSuspenseQueryResult<TData, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+    returnPartialData: true;
+})): UseSuspenseQueryResult<DeepPartial<TData> | undefined, TVariables>;
+
+// @public (undocumented)
+export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SkipToken | SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>): UseSuspenseQueryResult<TData | undefined, TVariables>;
+
+// @public (undocumented)
+export interface UseSuspenseQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+    // (undocumented)
+    client: ApolloClient<any>;
+    // (undocumented)
+    data: TData;
+    // (undocumented)
+    error: ApolloError | undefined;
+    // (undocumented)
+    fetchMore: FetchMoreFunction<TData, TVariables>;
+    // (undocumented)
+    networkStatus: NetworkStatus;
+    // (undocumented)
+    refetch: RefetchFunction<TData, TVariables>;
+    // Warning: (ae-forgotten-export) The symbol "SubscribeToMoreFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
+}
+
+// @public (undocumented)
+export type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";
+
+// @public (undocumented)
+export interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
+    // (undocumented)
+    fetchPolicy?: WatchQueryFetchPolicy;
+    // (undocumented)
+    initialFetchPolicy?: WatchQueryFetchPolicy;
+    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+    // Warning: (ae-forgotten-export) The symbol "RefetchWritePolicy" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    refetchWritePolicy?: RefetchWritePolicy;
+}
+
+// @public (undocumented)
+interface WriteContext extends ReadMergeModifyContext {
+    // (undocumented)
+    clientOnly: boolean;
+    // (undocumented)
+    deferred: boolean;
+    // Warning: (ae-forgotten-export) The symbol "FlavorableWriteContext" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    flavors: Map<string, FlavorableWriteContext>;
+    // (undocumented)
+    readonly fragmentMap: FragmentMap;
+    // (undocumented)
+    incomingById: Map<string, {
+        storeObject: StoreObject;
+        mergeTree?: MergeTree;
+        fieldNodeSet: Set<FieldNode>;
+    }>;
+    // Warning: (ae-forgotten-export) The symbol "FragmentMapFunction" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    lookupFragment: FragmentMapFunction;
+    // (undocumented)
+    merge<T>(existing: T, incoming: T): T;
+    // (undocumented)
+    overwrite: boolean;
+    // (undocumented)
+    readonly written: {
+        [dataId: string]: SelectionSetNode[];
+    };
+}
+
+// Warnings were encountered during analysis:
+//
+// src/cache/inmemory/policies.ts:98:3 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeySpecifier" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/policies.ts:167:3 - (ae-forgotten-export) The symbol "KeyArgsFunction" needs to be exported by the entry point index.d.ts
+// src/cache/inmemory/types.ts:126:3 - (ae-forgotten-export) The symbol "KeyFieldsFunction" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:112:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
+// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:116:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:149:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
+// src/core/QueryManager.ts:378:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
+// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
+// src/link/http/selectHttpOptionsAndBody.ts:128:32 - (ae-forgotten-export) The symbol "HttpQueryOptions" needs to be exported by the entry point index.d.ts
+// src/react/hooks/useBackgroundQuery.ts:24:3 - (ae-forgotten-export) The symbol "FetchMoreFunction" needs to be exported by the entry point index.d.ts
+// src/react/hooks/useBackgroundQuery.ts:25:3 - (ae-forgotten-export) The symbol "RefetchFunction" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```

From e1e2fbbe47abcd7980feac70c6bdc847428ce25d Mon Sep 17 00:00:00 2001
From: Lenz Weber-Tronic <lorenz.weber-tronic@apollographql.com>
Date: Thu, 14 Sep 2023 11:32:02 +0200
Subject: [PATCH 3/5] add workflow

---
 .github/workflows/api-extractor.yml | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 .github/workflows/api-extractor.yml

diff --git a/.github/workflows/api-extractor.yml b/.github/workflows/api-extractor.yml
new file mode 100644
index 00000000000..5b232f45133
--- /dev/null
+++ b/.github/workflows/api-extractor.yml
@@ -0,0 +1,26 @@
+name: Api Extractor
+on: pull_request
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  api-extractor:
+    name: Api-Extractor
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+
+      - name: Install dependencies (with cache)
+        uses: bahmutov/npm-install@v1
+
+      - name: Run build
+        run: npm run build
+
+      - name: Run Api-Extractor
+        run: npm run extract-api

From 0426c840715d091621c52c2c3060b3a1c7b028c9 Mon Sep 17 00:00:00 2001
From: Lenz Weber-Tronic <lorenz.weber-tronic@apollographql.com>
Date: Thu, 14 Sep 2023 11:41:21 +0200
Subject: [PATCH 4/5] formatting

---
 api-extractor.json | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/api-extractor.json b/api-extractor.json
index f49419996e2..20f6605a52a 100644
--- a/api-extractor.json
+++ b/api-extractor.json
@@ -42,7 +42,6 @@
 
   "dtsRollup": {
     "enabled": false
-
   },
   "tsdocMetadata": {
     "enabled": false
@@ -117,11 +116,11 @@
       }
     }
 
-      // "ae-extra-release-tag": {
-      //   "logLevel": "warning",
-      //   "addToApiReportFile": true
-      // },
-      //
-      // . . .
-    }
+    // "ae-extra-release-tag": {
+    //   "logLevel": "warning",
+    //   "addToApiReportFile": true
+    // },
+    //
+    // . . .
+  }
 }

From be151b0ffd4bba092929c5a32eb9c42b94d242a5 Mon Sep 17 00:00:00 2001
From: Lenz Weber-Tronic <lorenz.weber-tronic@apollographql.com>
Date: Thu, 14 Sep 2023 11:51:36 +0200
Subject: [PATCH 5/5] package lock

---
 package-lock.json | 336 ----------------------------------------------
 1 file changed, 336 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 34f91312874..ab3bdc1d49d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1269,38 +1269,6 @@
         "node": ">=12"
       }
     },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.7.tgz",
-      "integrity": "sha512-o0VVztxJPkfDYbaU1tA1G1iwKiBh6Zt3bX5OdHDoITMFdRg+Mgdt3nHXMEtNlIjYA/Xn6hmlOYDHjJfQUduPuw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.7.tgz",
-      "integrity": "sha512-ga8Dtpb01GorCi1dk3jEwDk3AK/3F+cR5P+//Tl0ERL2K2pK/J1f3t8hcJ+RRt3UYBV/uTL9GEnx7touX0KRPQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/@esbuild/darwin-arm64": {
       "version": "0.18.7",
       "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.7.tgz",
@@ -1317,278 +1285,6 @@
         "node": ">=12"
       }
     },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.7.tgz",
-      "integrity": "sha512-w7aeD1UjDFXqyrZQLBIPYGmLR+gJsl+7QSwmSz+nVrCZOB7cyWEkIjCF8s4inUD3ja3WtKUIqzX5S4qDnU5q7Q==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.7.tgz",
-      "integrity": "sha512-wKyySDdoKVOPn9eDci/b3eP3EJVAVXC3b2CiaHphhCKfh4n5pWLwj7Ue96anK1HnpcZ0Uti8Sw9xq3Im0earHA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.7.tgz",
-      "integrity": "sha512-rbfjbgSvzWRjQMKIntogK1d2oIAiA/ZVayXfK1WjcIIMQYLg74sAoT8CZBj30+bwn13YR0t6lgIxA1mJaS2Lhw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.7.tgz",
-      "integrity": "sha512-GpUBqqJnQ+7qdb7NqKNVj7TgD2JnLrEdzPtatPow77Me/EQ01GE1tHKZLePqhf5thdLDb5Se2Kcf4D9WTbSjmw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.7.tgz",
-      "integrity": "sha512-cwfxKYroaD5BZ42NsfxdVU1issD2NxcuJHlCNsN5LtWq+kZMpwmIVDCJxKlgLIG7zH/4yq8lTuZJurxq058GsA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.7.tgz",
-      "integrity": "sha512-SsvsGStwbArBcB/XNh+2MvUtgOLp0CR6Hn1PBWcdApCuAaMibHCDyzHS06+u/YOD1UpeXFHJZphix61HeVMH/w==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.7.tgz",
-      "integrity": "sha512-/dKQ3OLr2Tmj0kuf4ZJioD+qnADUEJSBaiuDbk8v5602HnNNBSGHPrEB6S8PSb8y8jWsX9MMnxqk5KpLTf86OQ==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.7.tgz",
-      "integrity": "sha512-x/k1+daIqiGJt0Yhr5llFJ/zkRg1XAqcS2ntAYzS3pHogO8oIyc+LjsINgVyFCeFMFUZ9Ae9W5z2Ib05bMum3g==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.7.tgz",
-      "integrity": "sha512-LegTDzK9gL/sTkiZUGYLigTISwppZJvQL3MRmFgXgHrj3IzdWkPgMwEtOItK3YiFzhBSSNyKA0mSKEg4UuK8JQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.7.tgz",
-      "integrity": "sha512-fjBl45O8ivc3Nl14hdGpbHoVtdHnYGsLpwnlv2rNyb5NOsgY3Y8EhVe/fqR9ndHgO4eL68knKxkrRveEJq+v1g==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.7.tgz",
-      "integrity": "sha512-apYLJsg3wd3hW8nEt7H++8c8rTDvwXxX7h7YeI89g1RDPCT2QSXTO/xT1BCvFa/BFFoau+yvepQg2o5556FIWQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.7.tgz",
-      "integrity": "sha512-f82sUnrzdoW4MiiCDn1G3RSsPH8+no+okDhkHgGTGa+5F5wZCyxdXxzR6ctsiimvyPn9FIu9Zs+MesVsBRwyTw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.7.tgz",
-      "integrity": "sha512-1TNDfpFYhIloHeqSRbJFjHFMYtTJWgqI2+S9uCLVCWrADLl5tCe8vQKDfkM7Afz/lZyqi6qEX/Eg2KA5S7FcNQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.7.tgz",
-      "integrity": "sha512-lBhsHaM6EYCmzQCj+xeFev+dgqTgpSRqF7qXrxp5V4waFuidTBbWgqSXY5rsLRNLOyMMCh1cA+RqF8UL30oOJQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.7.tgz",
-      "integrity": "sha512-p9ipv7rPKitXAAeufg5BzmyYZHZtFfrLGUX15+AxpTQqSZDAZd2wIusaOW5oONTf8RB53ujIqQw7W0QnZMuiUw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.7.tgz",
-      "integrity": "sha512-WmNxuE+j1wUT2rK+e1Oakx3zobS1rPpQudPytGM4nxXEGv0gpXEvnZnrykRwriNFbGVCwFJoE4txayjW76LsCw==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.7.tgz",
-      "integrity": "sha512-6RENfAwwL6dxQk/V1PxO/ejYRiOUVUaHi99hP3Dso/38jfNKFzU6YSSR/haJGNV/2wAHIgBMROQodna0IejAuA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.2.0.tgz",
@@ -5111,38 +4807,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/esbuild/node_modules/@esbuild/android-arm": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.7.tgz",
-      "integrity": "sha512-nDQ7AC5WVKOqxaip/E5YbaRgnilBMsoGKjoGLCeCOYNePaBCBDwJsLfa2fn3FEtktiLaAF990W592avsHjJ/Vg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/esbuild/node_modules/@esbuild/linux-loong64": {
-      "version": "0.18.7",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.7.tgz",
-      "integrity": "sha512-WOqQ0eaWGE/e9vmbxFT2exbWuXxHuG8ld0fN7oX5f0v7W6oveUIF4DLJYVae93t1+Icv5R0NBo8wv/o4hEvxBQ==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/escalade": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",