Copy disabled (too large)
Download .txt
Showing preview only (12,231K chars total). Download the full file to get everything.
Repository: apollographql/apollo-client
Branch: main
Commit: 5eb5cac1d4bb
Files: 936
Total size: 11.5 MB
Directory structure:
gitextract_ribxjpsg/
├── .api-reports/
│ ├── api-report-cache.api.md
│ ├── api-report-core.api.md
│ ├── api-report-dev.api.md
│ ├── api-report-errors.api.md
│ ├── api-report-incremental.api.md
│ ├── api-report-link.api.md
│ ├── api-report-link_batch-http.api.md
│ ├── api-report-link_batch.api.md
│ ├── api-report-link_client-awareness.api.md
│ ├── api-report-link_context.api.md
│ ├── api-report-link_error.api.md
│ ├── api-report-link_http.api.md
│ ├── api-report-link_persisted-queries.api.md
│ ├── api-report-link_remove-typename.api.md
│ ├── api-report-link_retry.api.md
│ ├── api-report-link_schema.api.md
│ ├── api-report-link_subscriptions.api.md
│ ├── api-report-link_utils.api.md
│ ├── api-report-link_ws.api.md
│ ├── api-report-local-state.api.md
│ ├── api-report-masking.api.md
│ ├── api-report-react.api.md
│ ├── api-report-react_compiled.api.md
│ ├── api-report-react_internal.api.md
│ ├── api-report-react_internal_compiler-runtime.api.md
│ ├── api-report-react_ssr.api.md
│ ├── api-report-testing.api.md
│ ├── api-report-testing_internal.api.md
│ ├── api-report-testing_react.api.md
│ ├── api-report-utilities.api.md
│ ├── api-report-utilities_environment.api.md
│ ├── api-report-utilities_internal.api.md
│ ├── api-report-utilities_internal_globals.api.md
│ ├── api-report-utilities_internal_ponyfills.api.md
│ ├── api-report-utilities_invariant.api.md
│ ├── api-report-utilities_subscriptions_relay.api.md
│ ├── api-report-v4-migration.api.md
│ ├── api-report-zz_removals.api.md
│ └── api-report.api.md
├── .attw.json
├── .changeset/
│ ├── README.md
│ └── config.json
├── .circleci/
│ └── config.yml
├── .claude/
│ ├── commands/
│ │ └── chores.md
│ ├── documentation.md
│ ├── hooks.md
│ └── settings.json
├── .git-blame-ignore-revs
├── .gitattributes
├── .github/
│ ├── CODEOWNERS
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug.yml
│ │ ├── feature-request.md
│ │ └── question-discussion.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ ├── dependabot.yml
│ ├── instructions/
│ │ └── apollo-client.instructions.md
│ └── workflows/
│ ├── api-extractor.yml
│ ├── arethetypeswrong.yml
│ ├── change-prerelease-tag.yml
│ ├── cleanup-checks.mjs
│ ├── cleanup-checks.yml
│ ├── close-stale-issues.yml
│ ├── compare-build-output.yml
│ ├── copilot-setup-steps.yml
│ ├── devtools-errorcodes.yml
│ ├── docmodel.yml
│ ├── exit-prerelease.yml
│ ├── issue-close-user-survey.yml
│ ├── knip.yml
│ ├── lock.yml
│ ├── prerelease.yml
│ ├── publish-pr-releases.yml
│ ├── release.yml
│ ├── scheduled-test-canary.yml
│ └── size-limit.yml
├── .gitignore
├── .npmrc
├── .prettierignore
├── .prettierrc
├── .semgrepignore
├── .size-limit.cjs
├── .size-limits.json
├── .vscode/
│ ├── launch.json
│ └── settings.json
├── CHANGELOG.md
├── CLAUDE.md
├── COLLABORATORS.md
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── ROADMAP.md
├── VERSIONING_POLICY.md
├── api-extractor.json
├── codegen/
│ ├── CHANGELOG.md
│ ├── local-state/
│ │ ├── config.ts
│ │ ├── index.ts
│ │ ├── plugin.ts
│ │ └── visitor.ts
│ ├── package.json
│ └── tsconfig.json
├── config/
│ ├── FixJSDOMEnvironment.js
│ ├── apiExtractor.ts
│ ├── babel.ts
│ ├── build.ts
│ ├── bundlesize.ts
│ ├── compare-build-output-to.sh
│ ├── compileTs.ts
│ ├── deprecateInternals.ts
│ ├── dirname.cjs
│ ├── entryPoints.ts
│ ├── exports.ts
│ ├── helpers.ts
│ ├── inlineInheritDoc.ts
│ ├── jest/
│ │ └── react-dom-17-client.js
│ ├── jest.config.ts
│ ├── listImports.ts
│ ├── madge.ts
│ ├── precheck.ts
│ ├── prepareDist.ts
│ ├── preserveTsIgnore.ts
│ ├── prettier/
│ │ ├── format-jsdoc.js
│ │ ├── format-mdx3.js
│ │ └── test.ts
│ ├── processInvariants.ts
│ ├── react-compiler.ts
│ ├── schema.package.json.ts
│ ├── size-limit/
│ │ ├── index.js
│ │ └── package.json
│ ├── tsconfig.json
│ ├── verifySourceMaps.ts
│ └── version.ts
├── docs/
│ ├── README.md
│ ├── shared/
│ │ └── MdxProvidedComponents.ts
│ ├── source/
│ │ ├── _sidebar.yaml
│ │ ├── api/
│ │ │ ├── cache/
│ │ │ │ └── InMemoryCache.mdx
│ │ │ ├── core/
│ │ │ │ ├── ApolloClient.mdx
│ │ │ │ └── ObservableQuery.mdx
│ │ │ ├── errors/
│ │ │ │ ├── CombinedGraphQLErrors.mdx
│ │ │ │ ├── CombinedProtocolErrors.mdx
│ │ │ │ ├── LinkError.mdx
│ │ │ │ ├── LocalStateError.mdx
│ │ │ │ ├── ServerError.mdx
│ │ │ │ ├── ServerParseError.mdx
│ │ │ │ └── UnconventionalError.mdx
│ │ │ ├── link/
│ │ │ │ ├── apollo-link-base-batch-http.mdx
│ │ │ │ ├── apollo-link-base-http.mdx
│ │ │ │ ├── apollo-link-batch-http.mdx
│ │ │ │ ├── apollo-link-batch.mdx
│ │ │ │ ├── apollo-link-client-awareness.mdx
│ │ │ │ ├── apollo-link-context.mdx
│ │ │ │ ├── apollo-link-error.mdx
│ │ │ │ ├── apollo-link-http.mdx
│ │ │ │ ├── apollo-link-persisted-queries.mdx
│ │ │ │ ├── apollo-link-remove-typename.mdx
│ │ │ │ ├── apollo-link-retry.mdx
│ │ │ │ ├── apollo-link-schema.mdx
│ │ │ │ ├── apollo-link-subscriptions.mdx
│ │ │ │ ├── apollo-link-ws.mdx
│ │ │ │ ├── apollo-link.mdx
│ │ │ │ ├── community-links.mdx
│ │ │ │ └── introduction.mdx
│ │ │ └── react/
│ │ │ ├── ApolloProvider.mdx
│ │ │ ├── hooks-experimental.mdx
│ │ │ ├── hooks.mdx
│ │ │ ├── preloading.mdx
│ │ │ ├── skipToken.mdx
│ │ │ ├── ssr.mdx
│ │ │ ├── testing.mdx
│ │ │ ├── useApolloClient.mdx
│ │ │ ├── useBackgroundQuery.mdx
│ │ │ ├── useFragment.mdx
│ │ │ ├── useLazyQuery.mdx
│ │ │ ├── useLoadableQuery.mdx
│ │ │ ├── useMutation.mdx
│ │ │ ├── useQuery.mdx
│ │ │ ├── useQueryRefHandlers.mdx
│ │ │ ├── useReactiveVar.mdx
│ │ │ ├── useReadQuery.mdx
│ │ │ ├── useSubscription.mdx
│ │ │ └── useSuspenseQuery.mdx
│ │ ├── caching/
│ │ │ ├── advanced-topics.mdx
│ │ │ ├── cache-configuration.mdx
│ │ │ ├── cache-field-behavior.mdx
│ │ │ ├── cache-interaction.mdx
│ │ │ ├── garbage-collection.mdx
│ │ │ ├── memory-management.mdx
│ │ │ └── overview.mdx
│ │ ├── data/
│ │ │ ├── defer.mdx
│ │ │ ├── directives.mdx
│ │ │ ├── document-transforms.mdx
│ │ │ ├── error-handling.mdx
│ │ │ ├── file-uploads.mdx
│ │ │ ├── fragments.mdx
│ │ │ ├── mutations.mdx
│ │ │ ├── operation-best-practices.mdx
│ │ │ ├── persisted-queries.mdx
│ │ │ ├── queries.mdx
│ │ │ ├── refetching.mdx
│ │ │ ├── subscriptions.mdx
│ │ │ ├── suspense.mdx
│ │ │ └── typescript.mdx
│ │ ├── development-testing/
│ │ │ ├── client-schema-mocking.mdx
│ │ │ ├── developer-tooling.mdx
│ │ │ ├── graphql-codegen.mdx
│ │ │ ├── reducing-bundle-size.mdx
│ │ │ ├── schema-driven-testing.mdx
│ │ │ └── testing.mdx
│ │ ├── get-started.mdx
│ │ ├── index.mdx
│ │ ├── integrations/
│ │ │ ├── integrations.mdx
│ │ │ ├── nextjs.mdx
│ │ │ ├── react-native.mdx
│ │ │ ├── react-router.mdx
│ │ │ ├── tanstack-start.mdx
│ │ │ └── webpack.mdx
│ │ ├── local-state/
│ │ │ ├── local-resolvers.mdx
│ │ │ ├── local-state-management.mdx
│ │ │ ├── managing-state-with-field-policies.mdx
│ │ │ └── reactive-variables.mdx
│ │ ├── migrating/
│ │ │ └── apollo-client-4-migration.mdx
│ │ ├── networking/
│ │ │ ├── advanced-http-networking.mdx
│ │ │ ├── authentication.mdx
│ │ │ └── basic-http-networking.mdx
│ │ ├── pagination/
│ │ │ ├── core-api.mdx
│ │ │ ├── cursor-based.mdx
│ │ │ ├── key-args.mdx
│ │ │ ├── offset-based.mdx
│ │ │ └── overview.mdx
│ │ ├── performance/
│ │ │ ├── babel.mdx
│ │ │ ├── optimistic-ui.mdx
│ │ │ ├── performance.mdx
│ │ │ └── server-side-rendering.mdx
│ │ └── why-apollo.mdx
│ └── tsconfig.json
├── eslint-local-rules/
│ ├── canonical-references.ts
│ ├── fixtures/
│ │ ├── file.ts
│ │ ├── react.tsx
│ │ └── tsconfig.json
│ ├── forbid-act-in-disabled-act-environment.test.ts
│ ├── forbid-act-in-disabled-act-environment.ts
│ ├── generics.ts
│ ├── import-from-export.test.ts
│ ├── import-from-export.ts
│ ├── index.mjs
│ ├── package.json
│ ├── require-disable-act-environment.test.ts
│ ├── require-disable-act-environment.ts
│ ├── require-using-disposable.test.ts
│ ├── require-using-disposable.ts
│ ├── testSetup.ts
│ └── tsconfig.json
├── eslint.config.mjs
├── integration-tests/
│ ├── .gitignore
│ ├── .npmrc
│ ├── api.har
│ ├── browser-esm/
│ │ ├── html/
│ │ │ ├── jsdeliver-esm.html
│ │ │ ├── jspm-prepared.html
│ │ │ └── unpkg-unmangled.html
│ │ ├── package.json
│ │ ├── playwright.config.ts
│ │ └── tests/
│ │ └── playwright/
│ │ ├── jsdeliver-esm.test.ts
│ │ ├── jspm-prepared.test.ts
│ │ └── unpkg-unmangled.test.ts
│ ├── cra5/
│ │ ├── package.json
│ │ ├── playwright.config.ts
│ │ ├── public/
│ │ │ └── index.html
│ │ ├── src/
│ │ │ ├── App.tsx
│ │ │ └── index.tsx
│ │ ├── tests/
│ │ │ └── playwright/
│ │ │ └── apollo-client.test.ts
│ │ └── tsconfig.json
│ ├── empty.har
│ ├── next/
│ │ ├── next-env.d.ts
│ │ ├── next.config.js
│ │ ├── package.json
│ │ ├── playwright.config.ts
│ │ ├── src/
│ │ │ ├── app/
│ │ │ │ ├── cc/
│ │ │ │ │ ├── ApolloWrapper.tsx
│ │ │ │ │ ├── layout.tsx
│ │ │ │ │ └── page.tsx
│ │ │ │ ├── client.ts
│ │ │ │ ├── layout.tsx
│ │ │ │ └── page.tsx
│ │ │ ├── libs/
│ │ │ │ ├── apolloClient.ts
│ │ │ │ └── schemaLink.ts
│ │ │ └── pages/
│ │ │ ├── _app.tsx
│ │ │ ├── pages-no-ssr.tsx
│ │ │ └── pages.tsx
│ │ ├── tests/
│ │ │ └── playwright/
│ │ │ └── apollo-client.test.ts
│ │ └── tsconfig.json
│ ├── node/
│ │ ├── package.json
│ │ ├── test-cjs.cjs
│ │ ├── test-esm.mjs
│ │ └── test-require-esm.cjs
│ ├── package.json
│ ├── peerdeps-tsc/
│ │ ├── .gitignore
│ │ ├── package.json
│ │ ├── src/
│ │ │ └── index.ts
│ │ └── tsconfig.json
│ ├── pnpm-workspace.yaml
│ ├── shared/
│ │ ├── fixture.ts
│ │ ├── package.json
│ │ └── playwright.config.ts
│ ├── vite/
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── playwright.config.ts
│ │ ├── src/
│ │ │ ├── ApolloLinkResultType.ts
│ │ │ ├── App.tsx
│ │ │ ├── enhanceDataStates.ts
│ │ │ ├── enhanceMaskingTypes.ts
│ │ │ └── main.tsx
│ │ ├── tests/
│ │ │ └── playwright/
│ │ │ └── apollo-client.test.ts
│ │ ├── tsconfig.json
│ │ ├── tsconfig.node.json
│ │ └── vite.config.ts
│ ├── vite-swc/
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── playwright.config.ts
│ │ ├── src/
│ │ │ ├── App.tsx
│ │ │ └── main.tsx
│ │ ├── tests/
│ │ │ └── playwright/
│ │ │ └── apollo-client.test.ts
│ │ ├── tsconfig.json
│ │ ├── tsconfig.node.json
│ │ └── vite.config.ts
│ └── wrapping-library/
│ ├── package.json
│ ├── src/
│ │ └── index.ts
│ └── tsconfig.json
├── jsconfig.json
├── knip.config.js
├── package.json
├── patches/
│ ├── @changesets+parse+0.4.0.patch
│ ├── @microsoft+api-extractor+7.49.1.patch
│ ├── @testing-library+react+16.1.0.patch
│ ├── eslint-plugin-testing-library+7.1.1.patch
│ ├── graphql-17-alpha9+17.0.0-alpha.9.patch
│ ├── optimism+0.18.0.patch
│ ├── pretty-format+29.7.0.patch
│ └── react-dom-17+17.0.2.patch
├── renovate.json
├── scripts/
│ ├── changesets/
│ │ └── categorized/
│ │ ├── categorize.js
│ │ ├── categorized.yaml
│ │ └── package.json
│ ├── codemods/
│ │ ├── ac2-to-ac3/
│ │ │ ├── README.md
│ │ │ ├── examples/
│ │ │ │ ├── client-and-cache.ts
│ │ │ │ ├── link-packages.js
│ │ │ │ └── react-packages.tsx
│ │ │ ├── imports.js
│ │ │ └── package.json
│ │ ├── ac3-to-ac4/
│ │ │ ├── CHANGELOG.md
│ │ │ ├── README.md
│ │ │ ├── package.json
│ │ │ ├── runLocally.sh
│ │ │ ├── src/
│ │ │ │ ├── @types/
│ │ │ │ │ └── jscodeshift.d.ts
│ │ │ │ ├── __testfixtures__/
│ │ │ │ │ ├── imports.input.ts
│ │ │ │ │ └── imports.output.ts
│ │ │ │ ├── __tests__/
│ │ │ │ │ ├── __snapshots__/
│ │ │ │ │ │ ├── exports.test.ts.snap
│ │ │ │ │ │ └── removals.test.ts.snap
│ │ │ │ │ ├── apolloClientInitialization.test.ts
│ │ │ │ │ ├── diffTransform.ts
│ │ │ │ │ ├── exports.json
│ │ │ │ │ ├── exports.new.json
│ │ │ │ │ ├── exports.removed.json
│ │ │ │ │ ├── exports.removed.local.json
│ │ │ │ │ ├── exports.test.ts
│ │ │ │ │ ├── fixtures.test.ts
│ │ │ │ │ ├── handleIdentifierRename.test.ts
│ │ │ │ │ ├── imports.test.ts
│ │ │ │ │ ├── legacyEntryPoints.test.ts
│ │ │ │ │ ├── links.test.ts
│ │ │ │ │ └── removals.test.ts
│ │ │ │ ├── apolloClientInitialization.ts
│ │ │ │ ├── cli.ts
│ │ │ │ ├── devLoader.js
│ │ │ │ ├── imports.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── legacyEntrypoints.ts
│ │ │ │ ├── links.ts
│ │ │ │ ├── removals.ts
│ │ │ │ ├── renames.ts
│ │ │ │ ├── types.ts
│ │ │ │ └── util/
│ │ │ │ ├── callExpressionToNewExpression.ts
│ │ │ │ ├── entryPointAliases.ts
│ │ │ │ ├── findImportDeclarationFor.ts
│ │ │ │ ├── findImportSpecifiersFor.ts
│ │ │ │ ├── findOrInsertImport.ts
│ │ │ │ ├── findReferences.ts
│ │ │ │ ├── getAllExports.ts
│ │ │ │ ├── getProperty.ts
│ │ │ │ ├── getUnusedIdentifier.ts
│ │ │ │ ├── handleIdentiferRename.ts
│ │ │ │ ├── handleModuleRename.ts
│ │ │ │ ├── monkeyPatchAstTypes.ts
│ │ │ │ ├── moveGlobalIdentifierToNamespaceAccess.ts
│ │ │ │ ├── pick.ts
│ │ │ │ ├── renameGlobalIdentifier.ts
│ │ │ │ └── reorderGenericArguments.ts
│ │ │ ├── tsconfig.build.json
│ │ │ ├── tsconfig.json
│ │ │ ├── tsconfig.tests.json
│ │ │ └── vitest.config.ts
│ │ ├── data-masking/
│ │ │ ├── examples/
│ │ │ │ ├── queries-codegen.ts
│ │ │ │ ├── queries-react.tsx
│ │ │ │ ├── queries.graphql
│ │ │ │ └── queries.ts
│ │ │ ├── package.json
│ │ │ ├── tsconfig.json
│ │ │ └── unmask.ts
│ │ └── misc/
│ │ └── mockLinkRejection.ts
│ └── memory/
│ ├── README.md
│ ├── package.json
│ ├── tests.cts
│ └── tsconfig.json
├── src/
│ ├── __tests__/
│ │ ├── ApolloClient.ts
│ │ ├── __snapshots__/
│ │ │ ├── ApolloClient.ts.snap
│ │ │ ├── client.ts.snap
│ │ │ ├── exports.ts.snap
│ │ │ └── mutationResults.ts.snap
│ │ ├── client.ts
│ │ ├── dataMasking.ts
│ │ ├── exports.ts
│ │ ├── fetchMore.ts
│ │ ├── graphqlSubscriptions.ts
│ │ ├── local-state/
│ │ │ ├── __snapshots__/
│ │ │ │ ├── export.ts.snap
│ │ │ │ └── general.ts.snap
│ │ │ ├── export.ts
│ │ │ ├── general.ts
│ │ │ ├── resolvers.ts
│ │ │ └── subscriptions.ts
│ │ ├── mutationResults.ts
│ │ ├── optimistic.ts
│ │ ├── refetchQueries.ts
│ │ ├── resultCacheCleaning.ts
│ │ └── subscribeToMore.ts
│ ├── cache/
│ │ ├── core/
│ │ │ ├── __tests__/
│ │ │ │ ├── cache.ts
│ │ │ │ └── cache.watchFragment/
│ │ │ │ └── types.test.ts
│ │ │ ├── cache.ts
│ │ │ └── types/
│ │ │ ├── Cache.ts
│ │ │ └── common.ts
│ │ ├── deprecated.ts
│ │ ├── index.ts
│ │ └── inmemory/
│ │ ├── __tests__/
│ │ │ ├── __snapshots__/
│ │ │ │ ├── cache.ts.snap
│ │ │ │ ├── entityStore.ts.snap
│ │ │ │ ├── fragmentMatcher.ts.snap
│ │ │ │ ├── policies.ts.snap
│ │ │ │ ├── roundtrip.ts.snap
│ │ │ │ └── writeToStore.ts.snap
│ │ │ ├── cache.ts
│ │ │ ├── cache.writeQuery/
│ │ │ │ └── extensions.test.ts
│ │ │ ├── diffAgainstStore.ts
│ │ │ ├── entityStore.ts
│ │ │ ├── fragmentMatcher.ts
│ │ │ ├── fragmentRegistry.ts
│ │ │ ├── helpers.ts
│ │ │ ├── key-extractor.ts
│ │ │ ├── optimistic.ts
│ │ │ ├── policies.ts
│ │ │ ├── readFromStore.ts
│ │ │ ├── recordingCache.ts
│ │ │ ├── roundtrip.ts
│ │ │ └── writeToStore.ts
│ │ ├── entityStore.ts
│ │ ├── fragmentRegistry.ts
│ │ ├── helpers.ts
│ │ ├── inMemoryCache.ts
│ │ ├── key-extractor.ts
│ │ ├── policies.ts
│ │ ├── reactiveVars.ts
│ │ ├── readFromStore.ts
│ │ ├── types.ts
│ │ └── writeToStore.ts
│ ├── config/
│ │ └── jest/
│ │ ├── areCombinedGraphQLErrorsEqual.ts
│ │ ├── areCombinedProtocolErrorsEqual.ts
│ │ ├── areGraphQlErrorsEqual.ts
│ │ ├── areLocalStateErrorsEqual.ts
│ │ ├── areMissingFieldErrorsEqual.ts
│ │ ├── areServerErrorsEqual.ts
│ │ ├── areWeakRefsEqual.ts
│ │ ├── resolver.ts
│ │ └── setup.ts
│ ├── core/
│ │ ├── ApolloClient.ts
│ │ ├── ObservableQuery.ts
│ │ ├── QueryInfo.ts
│ │ ├── QueryManager.ts
│ │ ├── __tests__/
│ │ │ ├── ApolloClient/
│ │ │ │ ├── general.test.ts
│ │ │ │ ├── links.test.ts
│ │ │ │ └── multiple-results.test.ts
│ │ │ ├── ObservableQuery.ts
│ │ │ ├── client.mutate/
│ │ │ │ └── refetchQueries.test.ts
│ │ │ ├── client.query/
│ │ │ │ ├── context.ts
│ │ │ │ └── defaultOptions.test.ts
│ │ │ ├── client.readFragment/
│ │ │ │ └── general.test.ts
│ │ │ ├── client.watchFragment/
│ │ │ │ ├── arrays.test.ts
│ │ │ │ ├── general.test.ts
│ │ │ │ ├── getCurrentResult.test.ts
│ │ │ │ └── types.test.ts
│ │ │ ├── client.watchQuery/
│ │ │ │ ├── defer20220824.test.ts
│ │ │ │ ├── deferGraphQL17Alpha9.test.ts
│ │ │ │ ├── streamDefer20220824.test.ts
│ │ │ │ └── streamGraphQL17Alpha9.test.ts
│ │ │ ├── client.writeFragment/
│ │ │ │ └── general.test.ts
│ │ │ ├── client.writeQuery/
│ │ │ │ └── extensions.test.ts
│ │ │ └── fetchPolicies.ts
│ │ ├── deprecated.ts
│ │ ├── index.ts
│ │ ├── networkStatus.ts
│ │ ├── types.ts
│ │ └── watchQueryOptions.ts
│ ├── dev/
│ │ ├── index.ts
│ │ ├── loadDevMessages.ts
│ │ ├── loadErrorMessageHandler.ts
│ │ ├── loadErrorMessages.ts
│ │ ├── setErrorMessageHandler.ts
│ │ └── symbol.ts
│ ├── errors/
│ │ ├── CombinedGraphQLErrors.ts
│ │ ├── CombinedProtocolErrors.ts
│ │ ├── LinkError.ts
│ │ ├── LocalStateError.ts
│ │ ├── ServerError.ts
│ │ ├── ServerParseError.ts
│ │ ├── UnconventionalError.ts
│ │ ├── __tests__/
│ │ │ ├── CombinedGraphQLErrors.test.ts
│ │ │ ├── CombinedProtocolErrors.test.ts
│ │ │ ├── LinkError.test.ts
│ │ │ └── is.test.ts
│ │ ├── index.ts
│ │ ├── isErrorLike.ts
│ │ └── utils.ts
│ ├── incremental/
│ │ ├── handlers/
│ │ │ ├── __tests__/
│ │ │ │ ├── defer20220824/
│ │ │ │ │ ├── defer.test.ts
│ │ │ │ │ └── stream.test.ts
│ │ │ │ └── graphql17Alpha9/
│ │ │ │ ├── defer.test.ts
│ │ │ │ └── stream.test.ts
│ │ │ ├── defer20220824.ts
│ │ │ ├── graphql17Alpha9.ts
│ │ │ └── notImplemented.ts
│ │ ├── index.ts
│ │ └── types.ts
│ ├── invariantErrorCodes.ts
│ ├── link/
│ │ ├── batch/
│ │ │ ├── __tests__/
│ │ │ │ └── batchLink.ts
│ │ │ ├── batchLink.ts
│ │ │ ├── batching.ts
│ │ │ └── index.ts
│ │ ├── batch-http/
│ │ │ ├── BaseBatchHttpLink.ts
│ │ │ ├── __tests__/
│ │ │ │ └── batchHttpLink.ts
│ │ │ ├── batchHttpLink.ts
│ │ │ └── index.ts
│ │ ├── client-awareness/
│ │ │ ├── ClientAwarenessLink.ts
│ │ │ ├── __tests__/
│ │ │ │ └── ClientAwarenessLink.test.ts
│ │ │ └── index.ts
│ │ ├── context/
│ │ │ ├── __tests__/
│ │ │ │ └── index.ts
│ │ │ └── index.ts
│ │ ├── core/
│ │ │ ├── ApolloLink.ts
│ │ │ ├── __tests__/
│ │ │ │ └── ApolloLink.ts
│ │ │ ├── concat.ts
│ │ │ ├── deprecated.ts
│ │ │ ├── empty.ts
│ │ │ ├── execute.ts
│ │ │ ├── from.ts
│ │ │ ├── split.ts
│ │ │ └── types.ts
│ │ ├── error/
│ │ │ ├── __tests__/
│ │ │ │ └── index.ts
│ │ │ └── index.ts
│ │ ├── http/
│ │ │ ├── BaseHttpLink.ts
│ │ │ ├── HttpLink.ts
│ │ │ ├── __tests__/
│ │ │ │ ├── HttpLink.ts
│ │ │ │ ├── checkFetcher.ts
│ │ │ │ ├── headerNormalization.ts
│ │ │ │ ├── helpers.ts
│ │ │ │ ├── parseAndCheckHttpResponse.ts
│ │ │ │ ├── responseIterator.ts
│ │ │ │ ├── responseIteratorNoAsyncIterator.ts
│ │ │ │ ├── selectHttpOptionsAndBody.ts
│ │ │ │ └── selectURI.ts
│ │ │ ├── checkFetcher.ts
│ │ │ ├── createSignalIfSupported.ts
│ │ │ ├── index.ts
│ │ │ ├── parseAndCheckHttpResponse.ts
│ │ │ ├── rewriteURIForGET.ts
│ │ │ ├── selectHttpOptionsAndBody.ts
│ │ │ └── selectURI.ts
│ │ ├── index.ts
│ │ ├── persisted-queries/
│ │ │ ├── __tests__/
│ │ │ │ ├── persisted-queries.test.ts
│ │ │ │ └── react.test.tsx
│ │ │ └── index.ts
│ │ ├── remove-typename/
│ │ │ ├── __tests__/
│ │ │ │ └── removeTypenameFromVariables.ts
│ │ │ ├── index.ts
│ │ │ └── removeTypenameFromVariables.ts
│ │ ├── retry/
│ │ │ ├── __tests__/
│ │ │ │ ├── delayFunction.ts
│ │ │ │ ├── retryFunction.ts
│ │ │ │ └── retryLink.ts
│ │ │ ├── delayFunction.ts
│ │ │ ├── index.ts
│ │ │ ├── retryFunction.ts
│ │ │ └── retryLink.ts
│ │ ├── schema/
│ │ │ ├── __tests__/
│ │ │ │ └── schemaLink.ts
│ │ │ └── index.ts
│ │ ├── subscriptions/
│ │ │ ├── __tests__/
│ │ │ │ └── graphqlWsLink.ts
│ │ │ └── index.ts
│ │ ├── utils/
│ │ │ ├── __tests__/
│ │ │ │ └── filterOperationVariables.ts
│ │ │ ├── createOperation.ts
│ │ │ ├── filterOperationVariables.ts
│ │ │ └── index.ts
│ │ └── ws/
│ │ ├── __tests__/
│ │ │ └── webSocketLink.ts
│ │ └── index.ts
│ ├── local-state/
│ │ ├── LocalState.ts
│ │ ├── __tests__/
│ │ │ └── LocalState/
│ │ │ ├── aliases.test.ts
│ │ │ ├── async.test.ts
│ │ │ ├── base.test.ts
│ │ │ ├── cache.test.ts
│ │ │ ├── context.test.ts
│ │ │ ├── errors.test.ts
│ │ │ ├── exports.test.ts
│ │ │ ├── fixtures/
│ │ │ │ ├── base-types.ts
│ │ │ │ ├── context-value.ts
│ │ │ │ ├── local-resolvers-without-context-value.ts
│ │ │ │ ├── local-resolvers.ts
│ │ │ │ └── localSchema.graphql
│ │ │ ├── forcedResolvers.test.ts
│ │ │ ├── fragments.test.ts
│ │ │ ├── partialData.test.ts
│ │ │ ├── rootValue.test.ts
│ │ │ ├── subscriptions.test.ts
│ │ │ ├── testUtils.ts
│ │ │ └── types.test.ts
│ │ └── index.ts
│ ├── masking/
│ │ ├── GraphQLCodegenDataMasking.ts
│ │ ├── PreserveTypes.ts
│ │ ├── __benches__/
│ │ │ └── types.bench.ts
│ │ ├── __tests__/
│ │ │ ├── maskFragment.test.ts
│ │ │ ├── maskOperation.test.ts
│ │ │ └── utils.test.ts
│ │ ├── index.ts
│ │ ├── internal/
│ │ │ └── types.ts
│ │ ├── maskDefinition.ts
│ │ ├── maskFragment.ts
│ │ ├── maskOperation.ts
│ │ ├── types.ts
│ │ └── utils.ts
│ ├── react/
│ │ ├── context/
│ │ │ ├── ApolloContext.ts
│ │ │ ├── ApolloProvider.tsx
│ │ │ └── __tests__/
│ │ │ └── ApolloProvider.test.tsx
│ │ ├── hooks/
│ │ │ ├── __tests__/
│ │ │ │ ├── bundle.test.tsx
│ │ │ │ ├── useApolloClient.test.tsx
│ │ │ │ ├── useBackgroundQuery/
│ │ │ │ │ ├── defer20220824.test.tsx
│ │ │ │ │ ├── deferGraphQL17Alpha9.test.tsx
│ │ │ │ │ ├── skipToken.test.tsx
│ │ │ │ │ ├── streamDefer20220824.test.tsx
│ │ │ │ │ ├── streamGraphQL17Alpha9.test.tsx
│ │ │ │ │ └── testUtils.tsx
│ │ │ │ ├── useBackgroundQuery.test.tsx
│ │ │ │ ├── useFragment/
│ │ │ │ │ └── arrays.test.tsx
│ │ │ │ ├── useFragment.test.tsx
│ │ │ │ ├── useLazyQuery.test.tsx
│ │ │ │ ├── useLoadableQuery/
│ │ │ │ │ ├── defer20220824.test.tsx
│ │ │ │ │ └── deferGraphQL17Alpha9.test.tsx
│ │ │ │ ├── useLoadableQuery.test.tsx
│ │ │ │ ├── useMutation/
│ │ │ │ │ ├── context.test.tsx
│ │ │ │ │ ├── defer20220824.test.tsx
│ │ │ │ │ └── deferGraphQL17Alpha9.test.tsx
│ │ │ │ ├── useMutation.test.tsx
│ │ │ │ ├── useQuery/
│ │ │ │ │ ├── defer20220824.test.tsx
│ │ │ │ │ ├── deferGraphQL17Alpha9.test.tsx
│ │ │ │ │ ├── streamDefer20220824.test.tsx
│ │ │ │ │ └── streamGraphQL17Alpha9.test.tsx
│ │ │ │ ├── useQuery.test.tsx
│ │ │ │ ├── useQueryRefHandlers.test.tsx
│ │ │ │ ├── useReactiveVar.test.tsx
│ │ │ │ ├── useSubscription.test.tsx
│ │ │ │ ├── useSuspenseFragment/
│ │ │ │ │ └── arrays.test.tsx
│ │ │ │ ├── useSuspenseFragment.test.tsx
│ │ │ │ ├── useSuspenseQuery/
│ │ │ │ │ ├── defer20220824.test.tsx
│ │ │ │ │ ├── deferGraphQL17Alpha9.test.tsx
│ │ │ │ │ ├── skipToken.test.tsx
│ │ │ │ │ ├── streamDefer20220824.test.tsx
│ │ │ │ │ ├── streamGraphQL17Alpha9.test.tsx
│ │ │ │ │ └── testUtils.tsx
│ │ │ │ └── useSuspenseQuery.test.tsx
│ │ │ ├── constants.ts
│ │ │ ├── internal/
│ │ │ │ ├── __tests__/
│ │ │ │ │ ├── useDeepMemo.test.ts
│ │ │ │ │ └── useRenderGuard.test.tsx
│ │ │ │ ├── __use.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── useDeepMemo.ts
│ │ │ │ ├── useIsomorphicLayoutEffect.ts
│ │ │ │ ├── useRenderGuard.ts
│ │ │ │ ├── useSuspenseHookCacheKey.ts
│ │ │ │ ├── validateSuspenseHookOptions.ts
│ │ │ │ └── wrapHook.ts
│ │ │ ├── useApolloClient.ts
│ │ │ ├── useBackgroundQuery.ts
│ │ │ ├── useFragment.ts
│ │ │ ├── useLazyQuery.ts
│ │ │ ├── useLoadableQuery.ts
│ │ │ ├── useMutation.ts
│ │ │ ├── useQuery.ts
│ │ │ ├── useQueryRefHandlers.ts
│ │ │ ├── useReactiveVar.ts
│ │ │ ├── useReadQuery.ts
│ │ │ ├── useSubscription.ts
│ │ │ ├── useSuspenseFragment.ts
│ │ │ ├── useSuspenseQuery.ts
│ │ │ └── useSyncExternalStore.ts
│ │ ├── index.react-server.ts
│ │ ├── index.ts
│ │ ├── internal/
│ │ │ ├── cache/
│ │ │ │ ├── FragmentReference.ts
│ │ │ │ ├── QueryReference.ts
│ │ │ │ ├── SuspenseCache.ts
│ │ │ │ ├── __tests__/
│ │ │ │ │ ├── QueryReference.test.tsx
│ │ │ │ │ └── SuspenseCache.ts
│ │ │ │ ├── getSuspenseCache.ts
│ │ │ │ └── types.ts
│ │ │ ├── compiler-runtime/
│ │ │ │ ├── LICENSE
│ │ │ │ └── index.ts
│ │ │ ├── index.ts
│ │ │ └── types.ts
│ │ ├── query-preloader/
│ │ │ ├── __tests__/
│ │ │ │ ├── createQueryPreloader/
│ │ │ │ │ ├── defer20220824.test.tsx
│ │ │ │ │ └── deferGraphQL17Alpha9.test.tsx
│ │ │ │ └── createQueryPreloader.test.tsx
│ │ │ └── createQueryPreloader.ts
│ │ ├── ssr/
│ │ │ ├── __tests__/
│ │ │ │ ├── __snapshots__/
│ │ │ │ │ ├── prerenderStatic.test.tsx.snap
│ │ │ │ │ └── useQuery.test.tsx.snap
│ │ │ │ ├── getDataFromTree.test.tsx
│ │ │ │ ├── polyfillReactDomTypes.d.ts
│ │ │ │ ├── prerenderStatic.test.tsx
│ │ │ │ ├── useQuery.test.tsx
│ │ │ │ ├── useQueryEndToEnd.test.tsx
│ │ │ │ └── useReactiveVar.test.tsx
│ │ │ ├── getDataFromTree.ts
│ │ │ ├── index.ts
│ │ │ ├── prerenderStatic.tsx
│ │ │ ├── renderToStringWithData.ts
│ │ │ └── useSSRQuery.ts
│ │ └── types/
│ │ ├── deprecated.ts
│ │ └── types.documentation.ts
│ ├── testing/
│ │ ├── core/
│ │ │ ├── mocking/
│ │ │ │ ├── __tests__/
│ │ │ │ │ ├── __snapshots__/
│ │ │ │ │ │ └── mockLink.ts.snap
│ │ │ │ │ └── mockLink.ts
│ │ │ │ ├── mockLink.ts
│ │ │ │ └── mockSubscriptionLink.ts
│ │ │ └── types/
│ │ │ └── deprecated.ts
│ │ ├── index.ts
│ │ ├── internal/
│ │ │ ├── ObservableStream.ts
│ │ │ ├── __tests__/
│ │ │ │ └── ObservableStream.test.ts
│ │ │ ├── asyncIterableSubject.ts
│ │ │ ├── declarations.d.ts
│ │ │ ├── disposables/
│ │ │ │ ├── __tests__/
│ │ │ │ │ ├── spyOnConsole.test.ts
│ │ │ │ │ └── withCleanup.test.ts
│ │ │ │ ├── enableFakeTimers.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── spyOnConsole.ts
│ │ │ │ ├── withCleanup.ts
│ │ │ │ └── withProdMode.ts
│ │ │ ├── incremental/
│ │ │ │ ├── executeSchemaGraphQL17Alpha2.ts
│ │ │ │ └── executeSchemaGraphQL17Alpha9.ts
│ │ │ ├── index.ts
│ │ │ ├── link.ts
│ │ │ ├── markAsStreaming.ts
│ │ │ ├── messageChannelPolyfill.ts
│ │ │ ├── multipart/
│ │ │ │ ├── mockDefer20220824.ts
│ │ │ │ ├── mockDeferStreamGraphql17Alpha9.ts
│ │ │ │ ├── mockMultipartSubscriptionStream.ts
│ │ │ │ └── utils.ts
│ │ │ ├── promiseWithResolvers.ts
│ │ │ ├── renderHelpers.tsx
│ │ │ ├── resetApolloContext.ts
│ │ │ ├── rtl/
│ │ │ │ ├── actAsync.ts
│ │ │ │ ├── renderAsync.ts
│ │ │ │ └── renderHookAsync.tsx
│ │ │ ├── scenarios/
│ │ │ │ └── index.ts
│ │ │ ├── schemas/
│ │ │ │ ├── friendList.graphql17Alpha2.ts
│ │ │ │ └── friendList.graphql17Alpha9.ts
│ │ │ └── wait.ts
│ │ ├── matchers/
│ │ │ ├── arrayWithLength.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index.ts
│ │ │ ├── isSameClient.ts
│ │ │ ├── isSameObservableQuery.ts
│ │ │ ├── toBeDisposed.ts
│ │ │ ├── toBeGarbageCollected.ts
│ │ │ ├── toComplete.ts
│ │ │ ├── toEmitAnything.ts
│ │ │ ├── toEmitError.ts
│ │ │ ├── toEmitNext.ts
│ │ │ ├── toEmitTypedValue.ts
│ │ │ ├── toHaveFragmentWatchesOn.ts
│ │ │ ├── toHaveNumWatches.ts
│ │ │ ├── toHaveSuspenseCacheEntryUsing.ts
│ │ │ ├── toMatchDocument.ts
│ │ │ ├── toRerenderWithSimilarSnapshot.ts
│ │ │ ├── toStrictEqualTyped.ts
│ │ │ └── utils/
│ │ │ └── getSerializableProperties.ts
│ │ └── react/
│ │ ├── MockedProvider.tsx
│ │ ├── __tests__/
│ │ │ ├── MockedProvider.test.tsx
│ │ │ ├── __snapshots__/
│ │ │ │ └── MockedProvider.test.tsx.snap
│ │ │ └── mockSubscriptionLink.test.tsx
│ │ └── index.ts
│ ├── utilities/
│ │ ├── DeepPartial.ts
│ │ ├── HKT.ts
│ │ ├── caching/
│ │ │ ├── __tests__/
│ │ │ │ ├── getMemoryInternals.ts
│ │ │ │ └── sizes.test.ts
│ │ │ ├── index.ts
│ │ │ └── sizes.ts
│ │ ├── common/
│ │ │ ├── __tests__/
│ │ │ │ ├── canonicalStringify.ts
│ │ │ │ └── stripTypename.ts
│ │ │ └── stripTypename.ts
│ │ ├── environment/
│ │ │ ├── index.development.ts
│ │ │ ├── index.production.ts
│ │ │ └── index.ts
│ │ ├── graphql/
│ │ │ ├── DocumentTransform.ts
│ │ │ ├── __tests__/
│ │ │ │ ├── DocumentTransform.ts
│ │ │ │ └── transform.ts
│ │ │ ├── isFormattedExecutionResult.ts
│ │ │ ├── operations.ts
│ │ │ ├── print.ts
│ │ │ ├── storeUtils.ts
│ │ │ └── transform.ts
│ │ ├── index.ts
│ │ ├── internal/
│ │ │ ├── DeepMerger.ts
│ │ │ ├── __tests__/
│ │ │ │ ├── DeepMerger.test.ts
│ │ │ │ ├── canUseDOM.test.ts
│ │ │ │ ├── checkDocument.test.ts
│ │ │ │ ├── cloneDeep.test.ts
│ │ │ │ ├── compact.test.ts
│ │ │ │ ├── createFragmentMap.test.ts
│ │ │ │ ├── equalByQuery.ts
│ │ │ │ ├── getDefaultValues.test.ts
│ │ │ │ ├── getFragmentDefinitions.test.ts
│ │ │ │ ├── getFragmentQueryDocument.test.ts
│ │ │ │ ├── getOperationName.test.ts
│ │ │ │ ├── getQueryDefinition.test.ts
│ │ │ │ ├── getStoreKeyName.test.ts
│ │ │ │ ├── hasDirectives.test.ts
│ │ │ │ ├── maybeDeepFreeze.test.ts
│ │ │ │ ├── mergeDeep.test.ts
│ │ │ │ ├── mergeDeepArray.test.ts
│ │ │ │ ├── omitDeep.test.ts
│ │ │ │ ├── removeDirectivesFromDocument.test.ts
│ │ │ │ └── shouldInclude.test.ts
│ │ │ ├── argumentsObjectFromField.ts
│ │ │ ├── bindCacheKey.ts
│ │ │ ├── caches.ts
│ │ │ ├── canUseDOM.ts
│ │ │ ├── canonicalStringify.ts
│ │ │ ├── checkDocument.ts
│ │ │ ├── cloneDeep.ts
│ │ │ ├── combineLatestBatched.ts
│ │ │ ├── compact.ts
│ │ │ ├── constants.ts
│ │ │ ├── createFragmentMap.ts
│ │ │ ├── createFulfilledPromise.ts
│ │ │ ├── createRejectedPromise.ts
│ │ │ ├── dealias.ts
│ │ │ ├── decoratePromise.ts
│ │ │ ├── deepFreeze.ts
│ │ │ ├── equalByQuery.ts
│ │ │ ├── filterMap.ts
│ │ │ ├── getDefaultValues.ts
│ │ │ ├── getFragmentDefinition.ts
│ │ │ ├── getFragmentDefinitions.ts
│ │ │ ├── getFragmentFromSelection.ts
│ │ │ ├── getFragmentQueryDocument.ts
│ │ │ ├── getGraphQLErrorsFromResult.ts
│ │ │ ├── getMainDefinition.ts
│ │ │ ├── getMemoryInternals.ts
│ │ │ ├── getOperationDefinition.ts
│ │ │ ├── getOperationName.ts
│ │ │ ├── getQueryDefinition.ts
│ │ │ ├── getStoreKeyName.ts
│ │ │ ├── globals/
│ │ │ │ ├── global.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── maybe.ts
│ │ │ ├── graphQLResultHasError.ts
│ │ │ ├── hasDirectives.ts
│ │ │ ├── hasForcedResolvers.ts
│ │ │ ├── index.production.ts
│ │ │ ├── index.ts
│ │ │ ├── isArray.ts
│ │ │ ├── isDocumentNode.ts
│ │ │ ├── isField.ts
│ │ │ ├── isNonEmptyArray.ts
│ │ │ ├── isNonNullObject.ts
│ │ │ ├── isPlainObject.ts
│ │ │ ├── makeReference.ts
│ │ │ ├── makeUniqueId.ts
│ │ │ ├── mapObservableFragment.ts
│ │ │ ├── maybeDeepFreeze.ts
│ │ │ ├── memoize.ts
│ │ │ ├── mergeDeep.ts
│ │ │ ├── mergeDeepArray.ts
│ │ │ ├── mergeOptions.ts
│ │ │ ├── omitDeep.ts
│ │ │ ├── ponyfills/
│ │ │ │ ├── FinalizationRegistry.ts
│ │ │ │ ├── __tests__/
│ │ │ │ │ └── FinalizationRegistry.test.ts
│ │ │ │ ├── index.react-native.ts
│ │ │ │ └── index.ts
│ │ │ ├── preventUnhandledRejection.ts
│ │ │ ├── removeDirectivesFromDocument.ts
│ │ │ ├── removeFragmentSpreads.ts
│ │ │ ├── resultKeyNameFromField.ts
│ │ │ ├── shouldInclude.ts
│ │ │ ├── storeKeyNameFromField.ts
│ │ │ ├── stringifyForDisplay.ts
│ │ │ ├── toQueryResult.ts
│ │ │ ├── types/
│ │ │ │ ├── ApplyHKT.ts
│ │ │ │ ├── ApplyHKTImplementationWithDefault.ts
│ │ │ │ ├── DecoratedPromise.ts
│ │ │ │ ├── DeepOmit.ts
│ │ │ │ ├── DocumentationTypes.ts
│ │ │ │ ├── ExtensionsWithStreamDetails.ts
│ │ │ │ ├── FragmentMap.ts
│ │ │ │ ├── FragmentMapFunction.ts
│ │ │ │ ├── FulfilledPromise.ts
│ │ │ │ ├── IsAny.ts
│ │ │ │ ├── NoInfer.ts
│ │ │ │ ├── PendingPromise.ts
│ │ │ │ ├── Prettify.ts
│ │ │ │ ├── Primitive.ts
│ │ │ │ ├── RejectedPromise.ts
│ │ │ │ ├── RemoveIndexSignature.ts
│ │ │ │ ├── StreamInfoTrie.ts
│ │ │ │ ├── TupleToIntersection.ts
│ │ │ │ ├── VariablesOption.ts
│ │ │ │ └── __tests__/
│ │ │ │ └── HTK.test.ts
│ │ │ └── valueToObjectRepresentation.ts
│ │ ├── invariant/
│ │ │ ├── __tests__/
│ │ │ │ └── invariant.test.ts
│ │ │ ├── index.development.ts
│ │ │ └── index.ts
│ │ ├── isNetworkRequestInFlight.ts
│ │ ├── isNetworkRequestSettled.ts
│ │ ├── policies/
│ │ │ ├── __tests__/
│ │ │ │ └── relayStylePagination.test.ts
│ │ │ └── pagination.ts
│ │ └── subscriptions/
│ │ └── relay/
│ │ ├── __tests__/
│ │ │ └── createFetchMultipartSubscription.test.ts
│ │ └── index.ts
│ ├── v4-migration.ts
│ └── version.ts
├── tests.codegen.ts
├── tsconfig.build.json
├── tsconfig.json
├── tsconfig.tests.json
└── tsdoc.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .api-reports/api-report-cache.api.md
================================================
## 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 { ApolloCache as ApolloCache_2 } from '@apollo/client';
import type { AsStoreObject } from '@apollo/client/utilities';
import { canonicalStringify } from '@apollo/client/utilities';
import type { DataValue } from '@apollo/client';
import type { DeepPartial } from '@apollo/client/utilities';
import type { DocumentNode } from 'graphql';
import type { DocumentNode as DocumentNode_2 } from '@apollo/client';
import type { ExtensionsWithStreamInfo } from '@apollo/client/utilities/internal';
import type { FieldNode } from 'graphql';
import type { FragmentDefinitionNode } from 'graphql';
import type { FragmentMap } from '@apollo/client/utilities/internal';
import type { FragmentMapFunction } from '@apollo/client/utilities/internal';
import type { FragmentType } from '@apollo/client/masking';
import { getApolloCacheMemoryInternals } from '@apollo/client/utilities/internal';
import type { GetDataState } from '@apollo/client';
import { getInMemoryCacheMemoryInternals } from '@apollo/client/utilities/internal';
import type { Incremental } from '@apollo/client/incremental';
import type { InlineFragmentNode } from 'graphql';
import type { IsAny } from '@apollo/client/utilities/internal';
import { isReference } from '@apollo/client/utilities';
import type { NoInfer as NoInfer_2 } from '@apollo/client/utilities/internal';
import { Observable } from 'rxjs';
import type { OperationVariables } from '@apollo/client';
import type { Prettify } from '@apollo/client/utilities/internal';
import { Reference } from '@apollo/client/utilities';
import type { SelectionSetNode } from 'graphql';
import type { StoreObject } from '@apollo/client/utilities';
import type { StoreValue } from '@apollo/client/utilities';
import { Trie } from '@wry/trie';
import type { TypedDocumentNode } from '@apollo/client';
import type { Unmasked } from '@apollo/client/masking';
// 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 namespace ApolloCache {
export type FromOptionValue<TData> = StoreObject | Reference | FragmentType<NoInfer_2<TData>> | string;
// (undocumented)
export interface ObservableFragment<TData = unknown> extends Observable<ApolloCache.WatchFragmentResult<TData>> {
getCurrentResult: () => ApolloCache.WatchFragmentResult<TData>;
}
export interface WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
fragmentName?: string;
from: ApolloCache.FromOptionValue<TData> | Array<ApolloCache.FromOptionValue<TData> | null> | null;
optimistic?: boolean;
variables?: TVariables;
}
export type WatchFragmentResult<TData = unknown> = true extends IsAny<TData> ? ({
complete: true;
missing?: never;
} & GetDataState<any, "complete">) | ({
complete: false;
missing?: MissingTree;
} & GetDataState<any, "partial">) : TData extends null | null[] ? Prettify<{
complete: true;
missing?: never;
} & GetDataState<TData, "complete">> : Prettify<{
complete: true;
missing?: never;
} & GetDataState<TData, "complete">> | {
complete: false;
missing?: MissingTree;
data: TData extends Array<infer TItem> ? Array<DataValue.Partial<TItem> | null> : DataValue.Partial<TData>;
dataState: "partial";
};
}
// @public (undocumented)
export abstract class ApolloCache {
// (undocumented)
readonly assumeImmutableResults: boolean;
batch<U>(options: Cache_2.BatchOptions<this, U>): U;
abstract diff<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
// (undocumented)
abstract evict(options: Cache_2.EvictOptions): boolean;
abstract extract(optimistic?: boolean): unknown;
// (undocumented)
abstract fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string): boolean;
// (undocumented)
gc(): string[];
// @internal @deprecated
getMemoryInternals?: typeof getApolloCacheMemoryInternals;
// (undocumented)
identify(object: StoreObject | Reference): string | undefined;
// (undocumented)
lookupFragment(fragmentName: string): FragmentDefinitionNode | null;
// (undocumented)
modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
protected onAfterBroadcast: (cb: () => void) => void;
// (undocumented)
abstract performTransaction(transaction: Transaction, optimisticId?: string | null): void;
// (undocumented)
abstract read<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: Cache_2.ReadOptions<TData, TVariables>): Unmasked<TData> | null;
readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, variables, fragmentName, id, from, optimistic, returnPartialData, }: Cache_2.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
// (undocumented)
readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache_2.ReadFragmentOptions<TData, TVariables>,
optimistic: boolean): Unmasked<TData> | null;
readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ query, variables, id, optimistic, returnPartialData, }: Cache_2.ReadQueryOptions<TData, TVariables>): Unmasked<TData> | null;
readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache_2.ReadQueryOptions<TData, TVariables>,
optimistic: boolean): Unmasked<TData> | null;
// (undocumented)
recordOptimisticTransaction(transaction: Transaction, optimisticId: string): void;
// (undocumented)
abstract removeOptimistic(id: string): void;
// (undocumented)
abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
resolvesClientField?(typename: string, fieldName: string): boolean;
abstract restore(serializedState: unknown): this;
// (undocumented)
transformDocument(document: DocumentNode): DocumentNode;
// (undocumented)
transformForLink(document: DocumentNode): DocumentNode;
// (undocumented)
updateFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
// (undocumented)
updateQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
// (undocumented)
abstract watch<TData = unknown, TVariables extends OperationVariables = OperationVariables>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
from: Array<ApolloCache.FromOptionValue<TData>>;
}): ApolloCache.ObservableFragment<Array<Unmasked<TData>>>;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
from: Array<null>;
}): ApolloCache.ObservableFragment<Array<null>>;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
from: Array<ApolloCache.FromOptionValue<TData> | null>;
}): ApolloCache.ObservableFragment<Array<Unmasked<TData> | null>>;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
from: null;
}): ApolloCache.ObservableFragment<null>;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
from: ApolloCache.FromOptionValue<TData>;
}): ApolloCache.ObservableFragment<Unmasked<TData>>;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables>): ApolloCache.ObservableFragment<Unmasked<TData> | null>;
// (undocumented)
abstract write<TData = unknown, TVariables extends OperationVariables = OperationVariables>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ data, fragment, fragmentName, variables, overwrite, id, from, broadcast, }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
writeQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ data, query, variables, overwrite, id, broadcast, }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
}
// @public (undocumented)
export type ApolloReducerConfig = {
dataIdFromObject?: KeyFieldsFunction;
};
// @public (undocumented)
type BroadcastOptions = Pick<Cache_2.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
// @public (undocumented)
namespace Cache_2 {
// (undocumented)
interface BatchOptions<TCache extends ApolloCache, TUpdateResult = void> {
onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff?: Cache_2.DiffResult<any> | undefined) => any;
optimistic?: string | boolean;
removeOptimistic?: string;
update(cache: TCache): TUpdateResult;
}
// (undocumented)
type CacheIdentifierOption<TData> = {
id?: string;
from?: never;
} | {
id?: never;
from?: ApolloCache.FromOptionValue<TData>;
};
// (undocumented)
interface DiffOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Omit<ReadOptions<TData, TVariables>, "rootId"> {
}
// (undocumented)
type DiffResult<TData> = {
result: DataValue.Complete<TData>;
complete: true;
missing?: never;
fromOptimisticTransaction?: boolean;
} | {
result: DataValue.Partial<TData> | null;
complete: false;
missing?: MissingFieldError;
fromOptimisticTransaction?: boolean;
};
// (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)
type ReadFragmentOptions<TData, TVariables extends OperationVariables> = {
fragment: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
fragmentName?: string;
variables?: TVariables;
returnPartialData?: boolean;
optimistic?: boolean;
} & Cache_2.CacheIdentifierOption<TData>;
// (undocumented)
interface ReadOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
id?: string;
// (undocumented)
optimistic: boolean;
// (undocumented)
previousResult?: any;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
// (undocumented)
returnPartialData?: boolean;
// (undocumented)
rootId?: string;
variables?: TVariables;
}
// (undocumented)
interface ReadQueryOptions<TData, TVariables extends OperationVariables> {
id?: string;
optimistic?: boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
returnPartialData?: boolean;
variables?: TVariables;
}
// (undocumented)
interface ResetOptions {
// (undocumented)
discardWatches?: boolean;
}
// (undocumented)
type UpdateFragmentOptions<TData, TVariables extends OperationVariables> = Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data" | "id" | "from"> & Cache_2.CacheIdentifierOption<TData>;
// (undocumented)
interface UpdateQueryOptions<TData, TVariables extends OperationVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
}
// (undocumented)
type WatchCallback<TData = unknown> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
// (undocumented)
interface WatchOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends DiffOptions<TData, TVariables> {
// (undocumented)
callback: WatchCallback<TData>;
// (undocumented)
immediate?: boolean;
// (undocumented)
lastDiff?: DiffResult<TData>;
// (undocumented)
watcher?: object;
}
// (undocumented)
type WriteFragmentOptions<TData, TVariables extends OperationVariables> = {
fragment: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
fragmentName?: string;
variables?: TVariables;
data: Unmasked<TData>;
broadcast?: boolean;
overwrite?: boolean;
} & Cache_2.CacheIdentifierOption<TData>;
// (undocumented)
interface WriteOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
broadcast?: boolean;
// (undocumented)
dataId?: string;
extensions?: ExtensionsWithStreamInfo;
overwrite?: boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
// (undocumented)
result: Unmasked<TData>;
variables?: TVariables;
}
// (undocumented)
interface WriteQueryOptions<TData, TVariables extends OperationVariables> {
broadcast?: boolean;
data: Unmasked<TData>;
extensions?: ExtensionsWithStreamInfo;
id?: string;
overwrite?: boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
variables?: TVariables;
}
}
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_2 | undefined;
withValue<TResult, TArgs extends any[], TThis = any>(value: ApolloCache_2, callback: (this: TThis, ...args: TArgs) => TResult, args?: TArgs | undefined, thisArg?: TThis | undefined): TResult;
};
export { canonicalStringify }
// @public (undocumented)
type CanReadFunction = (value: StoreValue) => boolean;
// @public (undocumented)
export function createFragmentRegistry(...fragments: DocumentNode[]): FragmentRegistryAPI;
// 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;
makeCacheKey(document: DocumentNode, callback: Cache_2.WatchCallback<any>, details: string): object;
makeCacheKey(selectionSet: SelectionSetNode, parent: string | StoreObject, varString: string | undefined): object;
makeCacheKey(field: FieldNode, array: readonly any[], varString: string | undefined): object;
// @deprecated (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>>, exact: boolean): 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;
// Warning: (ae-forgotten-export) The symbol "Root" needs to be exported by the entry point index.d.ts
//
// (undocumented)
static Root: typeof Root;
// (undocumented)
get supportsResultCaching(): boolean;
// (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 interface FieldFunctionOptions<TArgs = Record<string, any>, TVariables extends OperationVariables = 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?: TVariables;
}
// @public (undocumented)
export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldMergeFunctionOptions = FieldMergeFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
// @public (undocumented)
export interface FieldMergeFunctionOptions<TArgs = Record<string, any>, TVariables extends OperationVariables = Record<string, any>> extends FieldFunctionOptions<TArgs, TVariables> {
existingData: unknown;
extensions: Record<string, unknown> | undefined;
streamFieldInfo?: Incremental.StreamFieldInfo;
}
// @public (undocumented)
export function fieldNameFromStoreName(storeFieldName: string): string;
// @public (undocumented)
export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TReadOptions extends FieldReadFunctionOptions = FieldReadFunctionOptions, TMergeOptions extends FieldMergeFunctionOptions = FieldMergeFunctionOptions> = {
keyArgs?: KeySpecifier | KeyArgsFunction | false;
read?: FieldReadFunction<TExisting, TReadResult, TReadOptions>;
merge?: FieldMergeFunction<TExisting, TIncoming, TMergeOptions> | boolean;
};
// @public (undocumented)
export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldReadFunctionOptions = FieldReadFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
// @public (undocumented)
export interface FieldReadFunctionOptions<TArgs = Record<string, any>, TVariables extends OperationVariables = Record<string, any>> extends FieldFunctionOptions<TArgs, TVariables> {
}
// @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)
export interface FragmentRegistryAPI {
// (undocumented)
lookup(fragmentName: string): FragmentDefinitionNode | null;
// (undocumented)
register(...fragments: DocumentNode[]): this;
// (undocumented)
resetCaches(): void;
// (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 interface IgnoreModifier {
// (undocumented)
[_ignoreModifier]: true;
}
// @public (undocumented)
const _ignoreModifier: unique symbol;
// @public (undocumented)
export class InMemoryCache extends ApolloCache {
constructor(config?: InMemoryCacheConfig);
// (undocumented)
readonly assumeImmutableResults = true;
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 = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
// (undocumented)
evict(options: Cache_2.EvictOptions): boolean;
// (undocumented)
extract(optimistic?: boolean): NormalizedCacheObject;
// (undocumented)
fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string): boolean;
// (undocumented)
gc(options?: {
resetResultCache?: boolean;
}): string[];
// @internal @deprecated
getMemoryInternals?: typeof getInMemoryCacheMemoryInternals;
// (undocumented)
identify(object: StoreObject | Reference): string | undefined;
// (undocumented)
lookupFragment(fragmentName: string): FragmentDefinitionNode | null;
// (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<TData = unknown>(options: Cache_2.ReadOptions<TData, OperationVariables> & {
returnPartialData: true;
}): TData | DeepPartial<TData> | null;
// (undocumented)
read<TData = unknown>(options: Cache_2.ReadOptions<TData, OperationVariables>): TData | null;
// (undocumented)
release(rootId: string, optimistic?: boolean): number;
// (undocumented)
removeOptimistic(idToRemove: string): void;
// (undocumented)
reset(options?: Cache_2.ResetOptions): Promise<void>;
// (undocumented)
resolvesClientField(typename: string, fieldName: string): boolean;
// (undocumented)
restore(data: NormalizedCacheObject): this;
// (undocumented)
retain(rootId: string, optimistic?: boolean): number;
// (undocumented)
transformDocument(document: DocumentNode): DocumentNode;
// (undocumented)
watch<TData = unknown, TVariables extends OperationVariables = OperationVariables>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
// (undocumented)
write<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
}
// @public (undocumented)
export interface InMemoryCacheConfig extends ApolloReducerConfig {
// (undocumented)
fragments?: FragmentRegistryAPI;
// (undocumented)
possibleTypes?: PossibleTypesMap;
// (undocumented)
resultCaching?: boolean;
// (undocumented)
typePolicies?: TypePolicies;
}
// @public (undocumented)
interface InvalidateModifier {
// (undocumented)
[_invalidateModifier]: true;
}
// @public (undocumented)
const _invalidateModifier: unique symbol;
export { isReference }
// @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(...args: Parameters<EntityStore["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 makeVar<T>(value: T): ReactiveVar<T>;
// @public (undocumented)
export interface MergeInfo {
// (undocumented)
field: FieldNode;
// (undocumented)
merge: FieldMergeFunction;
// (undocumented)
path: Array<string | number>;
// (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) => DeepPartial<T> | DeleteModifier | InvalidateModifier | undefined;
// @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
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>, exact: boolean): boolean;
// (undocumented)
release(rootId: string): number;
replace(newData: NormalizedCacheObject): void;
retain(rootId: string): number;
toObject(): NormalizedCacheObject;
// (undocumented)
toReference: ToReferenceFunction;
}
// @public
export interface NormalizedCacheObject {
// (undocumented)
[dataId: string]: StoreObject | undefined;
// (undocumented)
__META?: {
extraRootIds: string[];
};
}
// @public (undocumented)
export type OptimisticStoreItem = {
id: string;
data: NormalizedCacheObject;
transaction: Transaction;
};
// @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, path }: 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_2): this;
// (undocumented)
forgetCache(cache: ApolloCache_2): 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)
extensions?: ExtensionsWithStreamInfo;
// (undocumented)
store: NormalizedCache;
// (undocumented)
variables?: OperationVariables;
// (undocumented)
varString?: string;
}
// @public (undocumented)
export type ReadQueryOptions = {
store: NormalizedCache;
query: DocumentNode;
variables?: Object;
previousResult?: any;
rootId?: string;
config?: ApolloReducerConfig;
};
export { Reference }
// @public (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 SafeReadonly<T> = T extends object ? Readonly<T> : T;
// @public (undocumented)
type StorageType = Record<string, any>;
export { StoreObject }
// @public (undocumented)
type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends ReadonlyArray<Record<string, any>> ? StoreVal extends ReadonlyArray<infer Item> ? [
Item
] extends [Record<string, any>] ? ReadonlyArray<AsStoreObject<Item> | Reference> : never : never : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference : StoreVal;
export { StoreValue }
// @public (undocumented)
class Stump extends Layer {
constructor(root: Root);
// (undocumented)
merge(older: string | StoreObject, newer: string | StoreObject): void;
// (undocumented)
removeLayer(): this;
}
// @public (undocumented)
type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
// @public (undocumented)
export type Transaction = (c: ApolloCache) => 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 @deprecated (undocumented)
export type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache_2.WatchFragmentOptions<TData, TVariables>;
// @public @deprecated (undocumented)
export type WatchFragmentResult<TData> = ApolloCache_2.WatchFragmentResult<TData>;
// @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/inmemory/policies.ts:173:3 - (ae-forgotten-export) The symbol "KeySpecifier" needs to be exported by the entry point index.d.ts
// src/cache/inmemory/policies.ts:173:3 - (ae-forgotten-export) The symbol "KeyArgsFunction" needs to be exported by the entry point index.d.ts
// src/cache/inmemory/types.ts:135:3 - (ae-forgotten-export) The symbol "KeyFieldsFunction" needs to be exported by the entry point index.d.ts
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-core.api.md
================================================
## 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 { ApolloCache } from '@apollo/client/cache';
import { ApolloLink } from '@apollo/client/link';
import { ApolloPayloadResult } from '@apollo/client/link';
import { ApolloReducerConfig } from '@apollo/client/cache';
import type { ApplyHKTImplementationWithDefault } from '@apollo/client/utilities/internal';
import { Cache as Cache_2 } from '@apollo/client/cache';
import { checkFetcher } from '@apollo/client/link/http';
import type { ClientAwarenessLink } from '@apollo/client/link/client-awareness';
import { CombinedGraphQLErrors } from '@apollo/client/errors';
import { CombinedProtocolErrors } from '@apollo/client/errors';
import { concat } from '@apollo/client/link';
import { createHttpLink } from '@apollo/client/link/http';
import { createSignalIfSupported } from '@apollo/client/link/http';
import type { DeepPartial } from '@apollo/client/utilities';
import { defaultDataIdFromObject } from '@apollo/client/cache';
import { defaultPrinter } from '@apollo/client/link/http';
import { DiffQueryAgainstStoreOptions } from '@apollo/client/cache';
import { disableExperimentalFragmentVariables } from 'graphql-tag';
import { disableFragmentWarnings } from 'graphql-tag';
import { DocumentNode } from '@apollo/client/link';
import type { DocumentNode as DocumentNode_2 } from 'graphql';
import { DocumentTransform } from '@apollo/client/utilities';
import { DocumentTransformCacheKey } from '@apollo/client/utilities';
import { empty } from '@apollo/client/link';
import { enableExperimentalFragmentVariables } from 'graphql-tag';
import { execute } from '@apollo/client/link';
import { extensionsSymbol } from '@apollo/client/utilities/internal';
import type { ExtensionsWithStreamInfo } from '@apollo/client/utilities/internal';
import { fallbackHttpConfig } from '@apollo/client/link/http';
import { FetchResult } from '@apollo/client/link';
import { FieldFunctionOptions } from '@apollo/client/cache';
import { FieldMergeFunction } from '@apollo/client/cache';
import { FieldPolicy } from '@apollo/client/cache';
import { FieldReadFunction } from '@apollo/client/cache';
import type { FormattedExecutionResult } from 'graphql';
import { FragmentType } from '@apollo/client/masking';
import { from } from '@apollo/client/link';
import { getApolloClientMemoryInternals } from '@apollo/client/utilities/internal';
import { gql } from 'graphql-tag';
import { GraphQLRequest } from '@apollo/client/link';
import type { HKT } from '@apollo/client/utilities';
import { HttpLink } from '@apollo/client/link/http';
import { IdGetter } from '@apollo/client/cache';
import { IdGetterObj } from '@apollo/client/cache';
import type { IgnoreModifier } from '@apollo/client/cache';
import type { Incremental } from '@apollo/client/incremental';
import { InMemoryCache } from '@apollo/client/cache';
import { InMemoryCacheConfig } from '@apollo/client/cache';
import type { InteropObservable } from 'rxjs';
import type { IsAny } from '@apollo/client/utilities/internal';
import { isNetworkRequestSettled } from '@apollo/client/utilities';
import { isReference } from '@apollo/client/utilities';
import { LinkError } from '@apollo/client/errors';
import type { LocalState } from '@apollo/client/local-state';
import { LocalStateError } from '@apollo/client/errors';
import { makeVar } from '@apollo/client/cache';
import { MaybeMasked } from '@apollo/client/masking';
import { MergeInfo } from '@apollo/client/cache';
import { MergeTree } from '@apollo/client/cache';
import { MissingFieldError } from '@apollo/client/cache';
import type { NextNotification } from 'rxjs';
import { NormalizedCache } from '@apollo/client/cache';
import { NormalizedCacheObject } from '@apollo/client/cache';
import { Observable } from '@apollo/client/utilities';
import { Observable as Observable_2 } from 'rxjs';
import type { ObservableNotification } from 'rxjs';
import type { Observer } from 'rxjs';
import { Operation } from '@apollo/client/link';
import { OperationTypeNode } from 'graphql';
import { OptimisticStoreItem } from '@apollo/client/cache';
import { parseAndCheckHttpResponse } from '@apollo/client/link/http';
import { PossibleTypesMap } from '@apollo/client/cache';
import { ReactiveVar } from '@apollo/client/cache';
import { ReadMergeModifyContext } from '@apollo/client/cache';
import { ReadQueryOptions } from '@apollo/client/cache';
import { Reference } from '@apollo/client/utilities';
import type { Reference as Reference_2 } from '@apollo/client/cache';
import { RequestHandler } from '@apollo/client/link';
import { resetCaches } from 'graphql-tag';
import { rewriteURIForGET } from '@apollo/client/link/http';
import { selectHttpOptionsAndBody } from '@apollo/client/link/http';
import { selectHttpOptionsAndBodyInternal } from '@apollo/client/link/http';
import { selectURI } from '@apollo/client/link/http';
import { ServerError } from '@apollo/client/errors';
import { ServerParseError } from '@apollo/client/errors';
import { setVerbosity as setLogVerbosity } from '@apollo/client/utilities/invariant';
import { split } from '@apollo/client/link';
import { StoreObject } from '@apollo/client/utilities';
import { StoreValue } from '@apollo/client/cache';
import type { Subscribable } from 'rxjs';
import type { Subscription } from 'rxjs';
import { Transaction } from '@apollo/client/cache';
import { Trie } from '@wry/trie';
import { TypedDocumentNode } from '@graphql-typed-document-node/core';
import { TypePolicies } from '@apollo/client/cache';
import { TypePolicy } from '@apollo/client/cache';
import { UnconventionalError } from '@apollo/client/errors';
import { Unmasked } from '@apollo/client/masking';
import type { VariablesOption } from '@apollo/client/utilities/internal';
import type { variablesUnknownSymbol } from '@apollo/client/utilities/internal';
import { WatchFragmentOptions } from '@apollo/client/cache';
import { WatchFragmentResult } from '@apollo/client/cache';
export { ApolloCache }
// @public (undocumented)
export namespace ApolloClient {
// (undocumented)
export namespace Base {
// (undocumented)
export interface ReadQueryOptions<TData, TVariables extends OperationVariables> {
id?: string;
optimistic?: boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
returnPartialData?: boolean;
}
}
// (undocumented)
export namespace Base {
// (undocumented)
export interface ReadFragmentOptions<TData, TVariables extends OperationVariables> {
fragment: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
fragmentName?: string;
optimistic?: boolean;
returnPartialData?: boolean;
}
}
// (undocumented)
export namespace Base {
// (undocumented)
export interface WriteQueryOptions<TData, TVariables extends OperationVariables> {
broadcast?: boolean;
data: Unmasked<TData>;
extensions?: Record<string, unknown>;
id?: string;
overwrite?: boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
}
}
// (undocumented)
export namespace Base {
// (undocumented)
export interface WriteFragmentOptions<TData, TVariables extends OperationVariables> {
broadcast?: boolean;
data: Unmasked<TData>;
fragment: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
fragmentName?: string;
overwrite?: boolean;
}
}
// (undocumented)
export interface DefaultOptions {
// (undocumented)
mutate?: Partial<ApolloClient.MutateOptions<any, any, any>>;
// (undocumented)
query?: Partial<ApolloClient.QueryOptions<any, any>>;
// (undocumented)
watchQuery?: Partial<ApolloClient.WatchQueryOptions<any, any>>;
}
// (undocumented)
export interface DevtoolsOptions {
enabled?: boolean;
name?: string;
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface ReadQueryOptions<TData, TVariables extends OperationVariables> extends Base.ReadQueryOptions<TData, TVariables> {
variables?: TVariables;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface ReadFragmentOptions<TData, TVariables extends OperationVariables> extends Base.ReadFragmentOptions<TData, TVariables> {
from?: ApolloCache.FromOptionValue<TData>;
id?: string;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
variables?: TVariables;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
variables?: TVariables;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface WriteFragmentOptions<TData, TVariables extends OperationVariables> extends Base.WriteFragmentOptions<TData, TVariables> {
from?: ApolloCache.FromOptionValue<TData>;
id?: string;
variables?: TVariables;
}
}
// (undocumented)
export interface Experiment {
// (undocumented)
(this: ApolloClient, options: ApolloClient.Options): void;
// (undocumented)
v: 1;
}
// (undocumented)
export type MutateOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = {
optimisticResponse?: Unmasked<NoInfer<TData>> | ((vars: TVariables, { IGNORE }: {
IGNORE: IgnoreModifier;
}) => Unmasked<NoInfer<TData>> | IgnoreModifier);
updateQueries?: MutationQueryReducersMap<TData>;
refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
awaitRefetchQueries?: boolean;
update?: MutationUpdaterFunction<TData, TVariables, TCache>;
onQueryUpdated?: OnQueryUpdated<any>;
errorPolicy?: ErrorPolicy;
context?: DefaultContext;
fetchPolicy?: MutationFetchPolicy;
keepRootFields?: boolean;
mutation: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
} & VariablesOption<NoInfer<TVariables>>;
// (undocumented)
export interface MutateResult<TData = unknown> {
data: TData | undefined;
error?: ErrorLike;
extensions?: Record<string, unknown>;
}
// (undocumented)
export interface ObservableFragment<TData = unknown> extends Observable_2<ApolloClient.WatchFragmentResult<TData>> {
getCurrentResult: () => ApolloClient.WatchFragmentResult<TData>;
}
// (undocumented)
export interface Options {
assumeImmutableResults?: boolean;
cache: ApolloCache;
// (undocumented)
clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
dataMasking?: boolean;
// (undocumented)
defaultContext?: Partial<DefaultContext>;
defaultOptions?: ApolloClient.DefaultOptions;
devtools?: ApolloClient.DevtoolsOptions;
// (undocumented)
documentTransform?: DocumentTransform;
// (undocumented)
enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
experiments?: ApolloClient.Experiment[];
incrementalHandler?: Incremental.Handler<any>;
link: ApolloLink;
// (undocumented)
localState?: LocalState;
queryDeduplication?: boolean;
ssrForceFetchDelay?: number;
ssrMode?: boolean;
}
export type QueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
errorPolicy?: ErrorPolicy;
context?: DefaultContext;
fetchPolicy?: FetchPolicy;
} & VariablesOption<NoInfer<TVariables>>;
// (undocumented)
export interface QueryResult<TData = unknown> {
data: TData | undefined;
error?: ErrorLike;
}
// (undocumented)
export type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache_2.CacheIdentifierOption<TData>;
// (undocumented)
export type ReadQueryOptions<TData, TVariables extends OperationVariables> = Base.ReadQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
export interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
include?: RefetchQueriesInclude;
onQueryUpdated?: OnQueryUpdated<TResult> | null;
optimistic?: boolean;
updateCache?: (cache: TCache) => void;
}
export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>>, RefetchQueriesResult.AdditionalProperties<TResult> {
}
// (undocumented)
export namespace RefetchQueriesResult {
// (undocumented)
export interface AdditionalProperties<TResult> {
queries: ObservableQuery<any>[];
results: InternalRefetchQueriesResult<TResult>[];
}
}
// (undocumented)
export type SubscribeOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
fetchPolicy?: FetchPolicy;
errorPolicy?: ErrorPolicy;
context?: DefaultContext;
extensions?: Record<string, any>;
} & VariablesOption<NoInfer<TVariables>>;
// (undocumented)
export interface SubscribeResult<TData = unknown> {
data: TData | undefined;
error?: ErrorLike;
extensions?: Record<string, unknown>;
}
// (undocumented)
export type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache.WatchFragmentOptions<TData, TVariables>;
// (undocumented)
export type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<MaybeMasked<TData>>;
export type WatchQueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
fetchPolicy?: WatchQueryFetchPolicy;
nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
initialFetchPolicy?: WatchQueryFetchPolicy;
refetchWritePolicy?: RefetchWritePolicy;
errorPolicy?: ErrorPolicy;
context?: DefaultContext;
pollInterval?: number;
notifyOnNetworkStatusChange?: boolean;
returnPartialData?: boolean;
skipPollAttempt?: () => boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
[variablesUnknownSymbol]?: boolean;
} & VariablesOption<NoInfer<TVariables>>;
// (undocumented)
export type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache_2.CacheIdentifierOption<TData>;
// (undocumented)
export type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
}
// @public
export class ApolloClient {
// (undocumented)
__actionHookForDevTools(cb: () => any): void;
constructor(options: ApolloClient.Options);
// (undocumented)
__requestRaw(request: ApolloLink.Request): Observable_2<ApolloLink.Result<unknown>>;
// (undocumented)
cache: ApolloCache;
clearStore(): Promise<any[]>;
// (undocumented)
get defaultContext(): Partial<DefaultContext>;
// (undocumented)
defaultOptions: ApolloClient.DefaultOptions;
// (undocumented)
readonly devtoolsConfig: ApolloClient.DevtoolsOptions;
// @deprecated (undocumented)
disableNetworkFetches: never;
get documentTransform(): DocumentTransform;
extract(optimistic?: boolean): unknown;
getMemoryInternals?: typeof getApolloClientMemoryInternals;
getObservableQueries(include?: RefetchQueriesInclude): Set<ObservableQuery<any>>;
// (undocumented)
link: ApolloLink;
get localState(): LocalState | undefined;
set localState(localState: LocalState);
mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
onClearStore(cb: () => Promise<any>): () => void;
onResetStore(cb: () => Promise<any>): () => void;
set prioritizeCacheValues(value: boolean);
get prioritizeCacheValues(): boolean;
query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
// (undocumented)
queryDeduplication: boolean;
readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
// @deprecated
readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadFragmentOptions<TData, TVariables>, optimistic: boolean): Unmasked<TData> | null;
readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadQueryOptions<TData, TVariables>): Unmasked<TData> | null;
// @deprecated
readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadQueryOptions<TData, TVariables>,
optimistic: boolean): Unmasked<TData> | null;
// @deprecated
reFetchObservableQueries: (includeStandby?: boolean) => Promise<ApolloClient.QueryResult<any>[]>;
refetchObservableQueries(includeStandby?: boolean): Promise<ApolloClient.QueryResult<any>[]>;
refetchQueries<TCache extends ApolloCache = ApolloCache, TResult = Promise<ApolloClient.QueryResult<any>>>(options: ApolloClient.RefetchQueriesOptions<TCache, TResult>): ApolloClient.RefetchQueriesResult<TResult>;
resetStore(): Promise<ApolloClient.QueryResult<any>[] | null>;
restore(serializedState: unknown): ApolloCache;
setLink(newLink: ApolloLink): void;
stop(): void;
subscribe<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.SubscribeOptions<TData, TVariables>): SubscriptionObservable<ApolloClient.SubscribeResult<MaybeMasked<TData>>>;
// (undocumented)
version: string;
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
from: Array<ApolloCache.FromOptionValue<TData>>;
}): ApolloClient.ObservableFragment<Array<TData>>;
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
from: Array<null>;
}): ApolloClient.ObservableFragment<Array<null>>;
// (undocumented)
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
from: Array<ApolloCache.FromOptionValue<TData> | null>;
}): ApolloClient.ObservableFragment<Array<TData | null>>;
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
from: null;
}): ApolloClient.ObservableFragment<null>;
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
from: ApolloCache.FromOptionValue<TData>;
}): ApolloClient.ObservableFragment<TData>;
watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables>): ApolloClient.ObservableFragment<TData | null>;
watchQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>): ObservableQuery<TData, TVariables>;
writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WriteFragmentOptions<TData, TVariables>): Reference_2 | undefined;
writeQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WriteQueryOptions<TData, TVariables>): Reference_2 | undefined;
}
// @public @deprecated (undocumented)
export type ApolloClientOptions = ApolloClient.Options;
export { ApolloLink }
export { ApolloPayloadResult }
// @public @deprecated (undocumented)
export type ApolloQueryResult<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = ObservableQuery.Result<TData, TStates>;
export { ApolloReducerConfig }
// @public (undocumented)
export const build: "source" | "esm" | "cjs";
export { Cache_2 as Cache }
export { checkFetcher }
export { CombinedGraphQLErrors }
export { CombinedProtocolErrors }
export { concat }
export { createHttpLink }
export { createSignalIfSupported }
// @public (undocumented)
export type DataState<TData> = {
data: DataValue.Complete<TData>;
dataState: "complete";
} | {
data: DataValue.Streaming<TData>;
dataState: "streaming";
} | {
data: DataValue.Partial<TData>;
dataState: "partial";
} | {
data: undefined;
dataState: "empty";
};
// @public (undocumented)
export namespace DataValue {
// Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
export type Complete<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Complete", OverridableTypes.Defaults, TData>;
export type Partial<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Partial", OverridableTypes.Defaults, TData>;
export type Streaming<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Streaming", OverridableTypes.Defaults, TData>;
}
// @public (undocumented)
export interface DefaultContext extends Record<string, any> {
// (undocumented)
clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
queryDeduplication?: boolean;
}
export { defaultDataIdFromObject }
// @public @deprecated (undocumented)
export type DefaultOptions = ApolloClient.DefaultOptions;
export { defaultPrinter }
// @public @deprecated (undocumented)
export type DevtoolsOptions = ApolloClient.DevtoolsOptions;
export { DiffQueryAgainstStoreOptions }
export { disableExperimentalFragmentVariables }
export { disableFragmentWarnings }
export { DocumentNode }
export { DocumentTransform }
export { DocumentTransformCacheKey }
export { empty }
export { enableExperimentalFragmentVariables }
// @public
export interface ErrorLike {
// (undocumented)
message: string;
// (undocumented)
name: string;
// (undocumented)
stack?: string;
}
// @public
export type ErrorPolicy = "none" | "ignore" | "all";
export { execute }
export { fallbackHttpConfig }
// @public
export type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache";
export { FetchResult }
export { FieldFunctionOptions }
export { FieldMergeFunction }
export { FieldPolicy }
export { FieldReadFunction }
export { FragmentType }
export { from }
// @public (undocumented)
export type GetDataState<TData, TState extends DataState<TData>["dataState"]> = Extract<DataState<TData>, {
dataState: TState;
}>;
export { gql }
export { GraphQLRequest }
export { HttpLink }
export { IdGetter }
export { IdGetterObj }
export { InMemoryCache }
export { InMemoryCacheConfig }
// 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, TResult> extends Omit<ApolloClient.RefetchQueriesOptions<TCache, TResult>, "include"> {
// (undocumented)
include?: InternalRefetchQueriesInclude;
// (undocumented)
removeOptimistic?: string;
}
// @public (undocumented)
export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloClient.QueryResult<any>> : TResult;
// @public (undocumented)
export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | ApolloClient.QueryOptions;
// @internal @deprecated (undocumented)
export namespace InternalTypes {
export type { NextFetchPolicyContext, QueryManager };
}
export { isNetworkRequestSettled }
export { isReference }
export { LinkError }
export { LocalStateError }
export { makeVar }
// @public (undocumented)
interface MaskFragmentOptions<TData> {
// (undocumented)
data: TData;
// (undocumented)
fragment: DocumentNode_2;
// (undocumented)
fragmentName?: string;
}
// @public (undocumented)
interface MaskOperationOptions<TData> {
cause?: object;
// (undocumented)
data: TData;
// (undocumented)
document: DocumentNode_2;
// (undocumented)
fetchPolicy?: WatchQueryFetchPolicy;
}
export { MaybeMasked }
export { MergeInfo }
export { MergeTree }
export { MissingFieldError }
// @public @deprecated (undocumented)
export type MutateResult<TData = unknown> = ApolloClient.MutateResult<TData>;
// @public (undocumented)
export type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
// @public @deprecated (undocumented)
export type MutationOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = ApolloClient.MutateOptions<TData, TVariables, TCache>;
// @public (undocumented)
export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
mutationResult: NormalizedExecutionResult<Unmasked<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_2;
// (undocumented)
variables: Record<string, any>;
}
// @public (undocumented)
export type MutationUpdaterFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache> = (cache: TCache, result: FormattedExecutionResult<Unmasked<TData>>, options: {
context?: DefaultContext;
variables?: TVariables;
}) => void;
// @public
export enum NetworkStatus {
error = 8,
fetchMore = 3,
loading = 1,
poll = 6,
ready = 7,
refetch = 4,
setVariables = 2,
streaming = 9
}
// @public (undocumented)
interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
// (undocumented)
initialFetchPolicy: WatchQueryFetchPolicy;
// (undocumented)
observable: ObservableQuery<TData, TVariables>;
// (undocumented)
options: ApolloClient.WatchQueryOptions<TData, TVariables>;
// (undocumented)
reason: "after-fetch" | "variables-changed";
}
export { NormalizedCache }
export { NormalizedCacheObject }
// @public
export type NormalizedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = Omit<FormattedExecutionResult<TData, TExtensions>, "data"> & GetDataState<TData, "streaming" | "complete">;
export { Observable }
// @public (undocumented)
interface ObservableAndInfo<TData> {
// (undocumented)
fromLink: boolean;
// Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
//
// (undocumented)
observable: Observable_2<QueryNotification.Value<TData>>;
}
// @public (undocumented)
export namespace ObservableQuery {
// @internal @deprecated
export interface CacheWatchOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Cache_2.WatchOptions<TData, TVariables> {
// @deprecated
lastOwnDiff?: Cache_2.DiffResult<TData>;
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface ObservableMethods<TData, OperatorResult> {
pipe(...operators: OperatorFunctionChain<ObservableQuery.Result<TData>, OperatorResult>): Observable_2<OperatorResult>;
subscribe(observerOrNext: Partial<Observer<ObservableQuery.Result<MaybeMasked<TData>>>> | ((value: ObservableQuery.Result<MaybeMasked<TData>>) => void)): Subscription;
}
// (undocumented)
export type OperatorFunctionChain<From, To> = [];
}
// (undocumented)
export type FetchMoreOptions<TData, TVariables extends OperationVariables, TFetchData = TData, TFetchVars extends OperationVariables = TVariables> = {
query?: DocumentNode_2 | TypedDocumentNode<TFetchData, TFetchVars>;
variables?: Partial<NoInfer<TFetchVars>>;
errorPolicy?: ErrorPolicy;
context?: DefaultContext;
updateQuery?: (previousQueryResult: Unmasked<TData>, options: {
fetchMoreResult: Unmasked<TFetchData>;
variables: TFetchVars;
}) => Unmasked<TData>;
};
// (undocumented)
export type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
fetchPolicy: WatchQueryFetchPolicy;
nextFetchPolicy?: WatchQueryFetchPolicy | ((this: ApolloClient.WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
initialFetchPolicy: WatchQueryFetchPolicy;
refetchWritePolicy?: RefetchWritePolicy;
errorPolicy?: ErrorPolicy;
context?: DefaultContext;
pollInterval?: number;
notifyOnNetworkStatusChange?: boolean;
returnPartialData?: boolean;
skipPollAttempt?: () => boolean;
query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
variables: TVariables;
};
// (undocumented)
export type Result<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = {
error?: ErrorLike;
loading: boolean;
networkStatus: NetworkStatus;
partial: boolean;
} & GetDataState<TData, TStates>;
export interface ResultPromise<T> extends Promise<T> {
retain(): this;
}
// (undocumented)
export interface SubscribeToMoreOptions<TData = unknown, TSubscriptionVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData, TVariables extends OperationVariables = TSubscriptionVariables> {
// (undocumented)
context?: DefaultContext;
// (undocumented)
document: DocumentNode_2 | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
// (undocumented)
onError?: (error: ErrorLike) => void;
// (undocumented)
updateQuery?: SubscribeToMoreUpdateQueryFn<TData, TVariables, TSubscriptionData>;
// (undocumented)
variables?: TSubscriptionVariables;
}
}
// @public (undocumented)
export class ObservableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ObservableQuery.Result<MaybeMasked<TData>>>, InteropObservable<ObservableQuery.Result<MaybeMasked<TData>>> {
// (undocumented)
["@@observable"]: () => Subscribable<ObservableQuery.Result<MaybeMasked<TData>>>;
// (undocumented)
[Symbol.observable]: () => Subscribable<ObservableQuery.Result<MaybeMasked<TData>>>;
constructor({ queryManager, options, transformedQuery, }: {
queryManager: QueryManager;
options: ApolloClient.WatchQueryOptions<TData, TVariables>;
transformedQuery?: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
queryId?: string;
});
// @internal @deprecated (undocumented)
applyOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(options: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>): Promise<ApolloClient.QueryResult<TFetchData>>;
// @internal @deprecated (undocumented)
getCacheDiff({ optimistic }?: {
optimistic?: boolean | undefined;
}): Cache_2.DiffResult<TData>;
// (undocumented)
getCurrentResult(): ObservableQuery.Result<MaybeMasked<TData>>;
// (undocumented)
hasObservers(): boolean;
// @internal @deprecated
_lastWrite?: unknown;
// @internal @deprecated (undocumented)
notify(scheduled?: boolean): void;
// (undocumented)
readonly options: ObservableQuery.Options<TData, TVariables>;
pipe: Observable_2<ObservableQuery.Result<MaybeMasked<TData>>>["pipe"];
// (undocumented)
get query(): TypedDocumentNode<TData, TVariables>;
// (undocumented)
readonly queryName?: string;
refetch(variables?: Partial<TVariables>): ObservableQuery.ResultPromise<ApolloClient.QueryResult<TData>>;
reobserve(newOptions?: Partial<ObservableQuery.Options<TData, TVariables>>): ObservableQuery.ResultPromise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
// @internal @deprecated
reset(): void;
setVariables(variables: TVariables): Promise<ApolloClient.QueryResult<TData>>;
startPolling(pollInterval: number): void;
stop(): void;
stopPolling(): void;
subscribe: (observerOrNext: Partial<Observer<ObservableQuery.Result<MaybeMasked<TData>>>> | ((value: ObservableQuery.Result<MaybeMasked<TData>>) => void)) => Subscription;
subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
updateQuery(mapFn: UpdateQueryMapFn<TData, TVariables>): void;
get variables(): TVariables;
}
// @public (undocumented)
export type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;
export { Operation }
// @public (undocumented)
export type OperationVariables = Record<string, any>;
export { OptimisticStoreItem }
// @public (undocumented)
namespace OverridableTypes {
// (undocumented)
interface Complete extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: this["arg1"];
}
// (undocumented)
interface Defaults {
// Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
//
// (undocumented)
Complete: Complete;
// Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
//
// (undocumented)
Partial: Partial;
// Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
//
// (undocumented)
Streaming: Streaming;
}
// (undocumented)
interface Partial extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: DeepPartial<this["arg1"]>;
}
// (undocumented)
interface Streaming extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: this["arg1"];
}
}
export { parseAndCheckHttpResponse }
export { PossibleTypesMap }
// @public (undocumented)
namespace QueryManager {
// (undocumented)
type Result<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = ObservableQuery.Result<TData, TStates> & {
[extensionsSymbol]?: ExtensionsWithStreamInfo;
};
}
// @public (undocumented)
class QueryManager {
// Warning: (ae-forgotten-export) The symbol "QueryManagerOptions" needs to be exported by the entry point index.d.ts
constructor(options: QueryManagerOptions);
// (undocumented)
readonly assumeImmutableResults: boolean;
// (undocumented)
broadcastQueries(): void;
// (undocumented)
get cache(): ApolloCache;
// (undocumented)
clearStore(options?: Cache_2.ResetOptions): Promise<void>;
// (undocumented)
readonly client: ApolloClient;
readonly clientOptions: ApolloClient.Options;
// (undocumented)
readonly dataMasking: boolean;
// (undocumented)
readonly defaultContext: Partial<DefaultContext>;
// (undocumented)
defaultOptions: ApolloClient.DefaultOptions;
// (undocumented)
readonly documentTransform: DocumentTransform;
// (undocumented)
protected fetchCancelFns: Map<string, (error: any) => any>;
// Warning: (ae-forgotten-export) The symbol "ObservableAndInfo" needs to be exported by the entry point index.d.ts
//
// (undocumented)
fetchObservableWithInfo<TData, TVariables extends OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>, { networkStatus, query, fetchQueryOperator, onCacheHit, observableQuery, exposeExtensions, }: {
networkStatus?: NetworkStatus;
query?: DocumentNode_2;
fetchQueryOperator?: <T>(source: Observable_2<T>) => Observable_2<T>;
onCacheHit?: () => void;
observableQuery?: ObservableQuery<TData, TVariables> | undefined;
exposeExtensions?: boolean;
}): ObservableAndInfo<TData>;
// (undocumented)
fetchQuery<TData, TVariables extends OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>, networkStatus?: NetworkStatus): Promise<ApolloClient.QueryResult<TData>>;
// (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_2): TransformCacheEntry;
// (undocumented)
getObservableQueries(include?: InternalRefetchQueriesInclude): Set<ObservableQuery<any, OperationVariables>>;
// (undocumented)
getVariables<TVariables extends OperationVariables>(document: DocumentNode_2, variables?: TVariables): TVariables;
// (undocumented)
readonly incrementalHandler: Incremental.Handler;
// (undocumented)
protected inFlightLinkObservables: Trie<{
observable?: Observable_2<ApolloLink.Result<any>>;
restart?: () => void;
}>;
// (undocumented)
get link(): ApolloLink;
// (undocumented)
localState: LocalState | undefined;
// Warning: (ae-forgotten-export) The symbol "MaskFragmentOptions" needs to be exported by the entry point index.d.ts
//
// (undocumented)
maskFragment<TData = unknown>(options: MaskFragmentOptions<TData>): TData;
// Warning: (ae-forgotten-export) The symbol "MaskOperationOptions" needs to be exported by the entry point index.d.ts
//
// (undocumented)
maskOperation<TData = unknown>(options: MaskOperationOptions<TData>): MaybeMasked<TData>;
// (undocumented)
mutate<TData, TVariables extends OperationVariables, TCache extends ApolloCache>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: ApolloClient.MutateOptions<TData, TVariables, TCache> & {
errorPolicy: ErrorPolicy;
fetchPolicy: MutationFetchPolicy;
}): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
// (undocumented)
mutationStore?: {
[mutationId: string]: MutationStoreValue;
};
obsQueries: Set<ObservableQuery<any, any>>;
prioritizeCacheValues: boolean;
// (undocumented)
query<TData, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
// (undocumented)
refetchObservableQueries(includeStandby?: boolean): Promise<ApolloClient.QueryResult<any>[]>;
// (undocumented)
refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache, TResult>): InternalRefetchQueriesMap<TResult>;
// (undocumented)
readonly ssrMode: boolean;
// (undocumented)
startGraphQLSubscription<TData = unknown>(options: ApolloClient.SubscribeOptions<TData>): SubscriptionObservable<ApolloClient.SubscribeResult<TData>>;
stop(): void;
// (undocumented)
transform(document: DocumentNode_2): DocumentNode_2;
// (undocumented)
watchQuery<TData, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>): ObservableQuery<TData, TVariables>;
}
// @public (undocumented)
interface QueryManagerOptions {
// (undocumented)
assumeImmutableResults: boolean;
// (undocumented)
client: ApolloClient;
// (undocumented)
clientOptions: ApolloClient.Options;
// (undocumented)
dataMasking: boolean;
// (undocumented)
defaultContext: Partial<DefaultContext> | undefined;
// (undocumented)
defaultOptions: ApolloClient.DefaultOptions;
// (undocumented)
documentTransform: DocumentTransform | null | undefined;
// (undocumented)
incrementalHandler: Incremental.Handler;
// (undocumented)
localState: LocalState | undefined;
// (undocumented)
onBroadcast: undefined | (() => void);
// (undocumented)
queryDeduplication: boolean;
// (undocumented)
ssrMode: boolean;
}
// @public (undocumented)
namespace QueryNotification {
// (undocumented)
type FromCache<TData> = NextNotification<ObservableQuery.Result<TData>> & {
source: "cache";
};
// (undocumented)
type FromNetwork<TData> = ObservableNotification<ObservableQuery.Result<TData>> & {
source: "network";
};
// (undocumented)
type NewNetworkStatus = NextNotification<{
resetError?: boolean;
}> & {
source: "newNetworkStatus";
};
// (undocumented)
type SetResult<TData> = NextNotification<ObservableQuery.Result<TData>> & {
source: "setResult";
};
// Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
//
// (undocumented)
type Value<TData> = FromCache<TData> | FromNetwork<TData> | NewNetworkStatus | SetResult<TData>;
}
// @public @deprecated (undocumented)
export type QueryOptions<TVariables extends OperationVariables = OperationVariables, TData = unknown> = ApolloClient.QueryOptions<TData, TVariables>;
export { ReactiveVar }
export { ReadMergeModifyContext }
export { ReadQueryOptions }
export { Reference }
// @public (undocumented)
export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
// @public (undocumented)
type RefetchQueriesIncludeShorthand = "all" | "active";
// @public @deprecated (undocumented)
export type RefetchQueriesOptions<TCache extends ApolloCache, TResult> = ApolloClient.RefetchQueriesOptions<TCache, TResult>;
// @public (undocumented)
export type RefetchQueriesPromiseResults<TResult> = IsAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloClient.QueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
// @public @deprecated (undocumented)
export type RefetchQueriesResult<TResult> = ApolloClient.RefetchQueriesResult<TResult>;
// @public (undocumented)
export type RefetchQueryDescriptor = string | DocumentNode_2;
// @public (undocumented)
export type RefetchWritePolicy = "merge" | "overwrite";
export { RequestHandler }
export { resetCaches }
export { rewriteURIForGET }
export { selectHttpOptionsAndBody }
export { selectHttpOptionsAndBodyInternal }
export { selectURI }
export { ServerError }
export { ServerParseError }
export { setLogVerbosity }
export { split }
export { StoreObject }
export { StoreValue }
// @public (undocumented)
export interface SubscribeToMoreFunction<TData, TVariables extends OperationVariables = OperationVariables> {
// (undocumented)
<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
}
// @public @deprecated (undocumented)
export type SubscribeToMoreOptions<TData = unknown, TSubscriptionVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData, TVariables extends OperationVariables = TSubscriptionVariables> = ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>;
// @public (undocumented)
export type SubscribeToMoreUpdateQueryFn<TData = unknown, TVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData> = {
(
unsafePreviousData: DeepPartial<Unmasked<TData>>, options: UpdateQueryOptions<TData, TVariables> & {
subscriptionData: {
data: Unmasked<TSubscriptionData>;
};
}): Unmasked<TData> | void;
};
// @public
export interface SubscriptionObservable<T> extends Observable_2<T> {
restart: () => void;
}
// @public @deprecated (undocumented)
export type SubscriptionOptions<TVariables extends OperationVariables = OperationVariables, TData = unknown> = ApolloClient.SubscribeOptions<TData, TVariables>;
export { Transaction }
// @public (undocumented)
interface TransformCacheEntry {
// (undocumented)
asQuery: DocumentNode_2;
// (undocumented)
clientQuery: DocumentNode_2 | null;
// (undocumented)
defaultVars: OperationVariables;
// (undocumented)
hasClientExports: boolean;
// (undocumented)
hasForcedResolvers: boolean;
// (undocumented)
hasIncrementalDirective: boolean;
// (undocumented)
hasNonreactiveDirective: boolean;
// (undocumented)
nonReactiveQuery: DocumentNode_2;
// (undocumented)
operationType: OperationTypeNode | undefined;
// (undocumented)
serverQuery: DocumentNode_2 | null;
// (undocumented)
violation?: Error | undefined;
}
export { TypedDocumentNode }
// @public (undocumented)
export interface TypeOverrides {
}
export { TypePolicies }
export { TypePolicy }
export { UnconventionalError }
export { Unmasked }
// @public (undocumented)
export interface UpdateQueryMapFn<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
// (undocumented)
(
unsafePreviousData: DeepPartial<Unmasked<TData>>, options: UpdateQueryOptions<TData, TVariables>): Unmasked<TData> | void;
}
// @public (undocumented)
export type UpdateQueryOptions<TData, TVariables extends OperationVariables> = {
variables?: TVariables;
} & ({
complete: true;
previousData: Unmasked<TData>;
} | {
complete: false;
previousData: DeepPartial<Unmasked<TData>> | undefined;
});
// @public (undocumented)
export const version: string;
export { WatchFragmentOptions }
export { WatchFragmentResult }
// @public (undocumented)
export type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network" | "standby";
// @public @deprecated (undocumented)
export type WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = unknown> = ApolloClient.WatchQueryOptions<TData, TVariables>;
// Warnings were encountered during analysis:
//
// src/core/ApolloClient.ts:375:5 - (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
// src/core/ObservableQuery.ts:371:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
// src/core/QueryManager.ts:195:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-dev.api.md
================================================
## 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
export type ErrorMessageHandler = {
(message: string | number, args: string[]): string | undefined;
};
// @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
export function loadErrorMessageHandler(...errorCodes: ErrorCodes[]): ErrorMessageHandler & ErrorCodes;
// @public (undocumented)
export function loadErrorMessages(): void;
// @public
export function setErrorMessageHandler(handler: ErrorMessageHandler): void;
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-errors.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import { ErrorLike } from '@apollo/client';
import type { FormattedExecutionResult } from 'graphql';
import type { GraphQLFormattedError } from 'graphql';
// @public (undocumented)
export namespace CombinedGraphQLErrors {
// (undocumented)
export namespace DocumentationTypes {
export function formatMessage(errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions): string;
// (undocumented)
export interface InstanceProperties {
readonly data: Record<string, unknown> | null | undefined;
readonly errors: ReadonlyArray<GraphQLFormattedError>;
readonly extensions: Record<string, unknown> | undefined;
}
export function is(error: unknown): boolean;
}
export type MessageFormatter = (errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions) => string;
// (undocumented)
export interface MessageFormatterOptions {
defaultFormatMessage: (errors: ReadonlyArray<GraphQLFormattedError>) => string;
result: ApolloLink.Result<unknown>;
}
}
// @public
export class CombinedGraphQLErrors extends Error {
constructor(result: FormattedExecutionResult<any>);
constructor(result: ApolloLink.Result<any>, errors: ReadonlyArray<GraphQLFormattedError>);
readonly data: Record<string, unknown> | null | undefined;
readonly errors: ReadonlyArray<GraphQLFormattedError>;
readonly extensions: Record<string, unknown> | undefined;
static formatMessage: CombinedGraphQLErrors.MessageFormatter;
static is(error: unknown): error is CombinedGraphQLErrors;
}
// @public (undocumented)
export namespace CombinedProtocolErrors {
// (undocumented)
export namespace DocumentationTypes {
export function formatMessage(errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions): string;
// (undocumented)
export interface InstanceProperties {
readonly errors: ReadonlyArray<GraphQLFormattedError>;
}
}
export type MessageFormatter = (errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions) => string;
// (undocumented)
export interface MessageFormatterOptions {
defaultFormatMessage: (errors: ReadonlyArray<GraphQLFormattedError>) => string;
}
}
// @public
export class CombinedProtocolErrors extends Error {
constructor(protocolErrors: Array<GraphQLFormattedError> | ReadonlyArray<GraphQLFormattedError>);
readonly errors: ReadonlyArray<GraphQLFormattedError>;
static formatMessage: CombinedProtocolErrors.MessageFormatter;
static is(error: unknown): error is CombinedProtocolErrors;
}
// @public (undocumented)
export function graphQLResultHasProtocolErrors<T extends {}>(result: T): result is T & {
extensions: Record<string | symbol, any>;
};
// @public (undocumented)
export function isErrorLike(error: unknown): error is ErrorLike;
// @public
export const LinkError: {
is: (error: unknown) => boolean;
};
// @public (undocumented)
export namespace LocalStateError {
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface InstanceProperties {
readonly path?: Array<string | number>;
}
}
// (undocumented)
export interface Options {
// (undocumented)
path?: Array<string | number>;
// (undocumented)
sourceError?: unknown;
}
}
// @public
export class LocalStateError extends Error {
constructor(message: string, options?: LocalStateError.Options);
static is(error: unknown): error is LocalStateError;
readonly path?: Array<string | number>;
}
// @public (undocumented)
export const PROTOCOL_ERRORS_SYMBOL: unique symbol;
// @internal @deprecated
export function registerLinkError(error: ErrorLike): void;
// @public (undocumented)
export namespace ServerError {
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface InstanceProperties {
readonly bodyText: string;
readonly response: Response;
readonly statusCode: number;
}
}
// (undocumented)
export interface Options {
// (undocumented)
bodyText: string;
// (undocumented)
response: Response;
}
}
// @public
export class ServerError extends Error {
constructor(message: string, options: ServerError.Options);
readonly bodyText: string;
static is(error: unknown): error is ServerError;
readonly response: Response;
readonly statusCode: number;
}
// @public (undocumented)
export namespace ServerParseError {
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export interface InstanceProperties {
readonly bodyText: string;
readonly response: Response;
readonly statusCode: number;
}
}
// (undocumented)
export interface Options {
// (undocumented)
bodyText: string;
// (undocumented)
response: Response;
}
}
// @public
export class ServerParseError extends Error {
constructor(originalParseError: unknown, options: ServerParseError.Options);
readonly bodyText: string;
static is(error: unknown): error is ServerParseError;
readonly response: Response;
readonly statusCode: number;
}
// @public (undocumented)
export function toErrorLike(error: unknown): ErrorLike;
// @public
export class UnconventionalError extends Error {
constructor(errorType: unknown);
static is(error: unknown): error is UnconventionalError;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-incremental.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { DeepPartial } from '@apollo/client/utilities';
import type { DocumentNode } from 'graphql';
import type { FormattedExecutionResult } from 'graphql';
import type { GraphQLFormattedError } from 'graphql';
import type { HKT } from '@apollo/client/utilities';
// @public (undocumented)
namespace Defer20220824Handler {
// (undocumented)
type Chunk<TData extends Record<string, unknown>> = InitialResult<TData> | SubsequentResult<TData>;
// (undocumented)
interface Defer20220824Result extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
arg2: unknown;
// (undocumented)
return: Defer20220824Handler.Chunk<Record<string, unknown>>;
}
// (undocumented)
type IncrementalDeferResult<TData = Record<string, unknown>> = {
data?: TData | null;
errors?: ReadonlyArray<GraphQLFormattedError>;
extensions?: Record<string, unknown>;
path?: Incremental.Path;
label?: string;
};
// (undocumented)
type IncrementalResult<TData = Record<string, unknown>> = IncrementalDeferResult<TData> | IncrementalStreamResult<TData>;
// (undocumented)
type IncrementalStreamResult<TData = Array<unknown>> = {
errors?: ReadonlyArray<GraphQLFormattedError>;
items?: TData;
path?: Incremental.Path;
label?: string;
extensions?: Record<string, unknown>;
};
// (undocumented)
type InitialResult<TData = Record<string, unknown>> = {
data?: TData | null | undefined;
errors?: ReadonlyArray<GraphQLFormattedError>;
extensions?: Record<string, unknown>;
hasNext: boolean;
incremental?: ReadonlyArray<IncrementalResult<TData>>;
};
// (undocumented)
type SubsequentResult<TData = Record<string, unknown>> = {
extensions?: Record<string, unknown>;
hasNext: boolean;
incremental?: Array<IncrementalResult<TData>>;
};
// (undocumented)
interface TypeOverrides {
// (undocumented)
AdditionalApolloLinkResultTypes: Defer20220824Result;
}
}
// @public
class Defer20220824Handler implements Incremental.Handler<Defer20220824Handler.Chunk<any>> {
// (undocumented)
extractErrors(result: ApolloLink.Result<any>): GraphQLFormattedError[] | undefined;
// (undocumented)
isIncrementalResult(result: Record<string, any>): result is Defer20220824Handler.SubsequentResult | Defer20220824Handler.InitialResult;
// (undocumented)
prepareRequest(request: ApolloLink.Request): ApolloLink.Request;
// Warning: (ae-forgotten-export) The symbol "DeferRequest" needs to be exported by the entry point index.d.ts
//
// (undocumented)
startRequest<TData extends Record<string, unknown>>(_: {
query: DocumentNode;
}): DeferRequest<TData>;
}
export { Defer20220824Handler }
export { Defer20220824Handler as GraphQL17Alpha2Handler }
// @public (undocumented)
class DeferRequest<TData extends Record<string, unknown>> implements Incremental.IncrementalRequest<Defer20220824Handler.Chunk<TData>, TData> {
// (undocumented)
handle(cacheData: TData | DeepPartial<TData> | null | undefined, chunk: Defer20220824Handler.Chunk<TData>): FormattedExecutionResult<TData>;
// (undocumented)
hasNext: boolean;
}
// @public (undocumented)
export namespace GraphQL17Alpha9Handler {
// (undocumented)
export type Chunk<TData> = InitialResult<TData> | SubsequentResult<TData>;
// (undocumented)
export interface CompletedResult {
// (undocumented)
errors?: ReadonlyArray<GraphQLFormattedError>;
// (undocumented)
id: string;
}
// (undocumented)
export interface GraphQL17Alpha9Result extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
arg2: unknown;
// (undocumented)
return: GraphQL17Alpha9Handler.Chunk<Record<string, unknown>>;
}
// (undocumented)
export interface IncrementalDeferResult<TData = Record<string, unknown>> {
// (undocumented)
data: TData;
// (undocumented)
errors?: ReadonlyArray<GraphQLFormattedError>;
// (undocumented)
extensions?: Record<string, unknown>;
// (undocumented)
id: string;
// (undocumented)
subPath?: Incremental.Path;
}
// (undocumented)
export type IncrementalResult<TData = unknown> = IncrementalDeferResult<TData> | IncrementalStreamResult<TData>;
// (undocumented)
export interface IncrementalStreamResult<TData = ReadonlyArray<unknown>> {
// (undocumented)
errors?: ReadonlyArray<GraphQLFormattedError>;
// (undocumented)
extensions?: Record<string, unknown>;
// (undocumented)
id: string;
// (undocumented)
items: TData;
// (undocumented)
subPath?: Incremental.Path;
}
// (undocumented)
export type InitialResult<TData = Record<string, unknown>> = {
data: TData;
errors?: ReadonlyArray<GraphQLFormattedError>;
pending: ReadonlyArray<PendingResult>;
hasNext: boolean;
extensions?: Record<string, unknown>;
};
// (undocumented)
export interface PendingResult {
// (undocumented)
id: string;
// (undocumented)
label?: string;
// (undocumented)
path: Incremental.Path;
}
// (undocumented)
export type SubsequentResult<TData = unknown> = {
hasNext: boolean;
pending?: ReadonlyArray<PendingResult>;
incremental?: ReadonlyArray<IncrementalResult<TData>>;
completed?: ReadonlyArray<CompletedResult>;
extensions?: Record<string, unknown>;
};
// (undocumented)
export interface TypeOverrides {
// (undocumented)
AdditionalApolloLinkResultTypes: GraphQL17Alpha9Result;
}
}
// @public
export class GraphQL17Alpha9Handler implements Incremental.Handler<GraphQL17Alpha9Handler.Chunk<any>> {
// @internal @deprecated (undocumented)
extractErrors(result: ApolloLink.Result<any>): GraphQLFormattedError[] | undefined;
// @internal @deprecated (undocumented)
isIncrementalResult(result: ApolloLink.Result<any>): result is GraphQL17Alpha9Handler.InitialResult | GraphQL17Alpha9Handler.SubsequentResult;
// @internal @deprecated (undocumented)
prepareRequest(request: ApolloLink.Request): ApolloLink.Request;
// Warning: (ae-forgotten-export) The symbol "IncrementalRequest" needs to be exported by the entry point index.d.ts
//
// @internal @deprecated (undocumented)
startRequest<TData>(_: {
query: DocumentNode;
}): IncrementalRequest<TData>;
}
// @public (undocumented)
export namespace Incremental {
// @internal @deprecated (undocumented)
export interface Handler<Chunk extends Record<string, unknown> = Record<string, unknown>> {
// (undocumented)
extractErrors: (result: ApolloLink.Result<any>) => readonly GraphQLFormattedError[] | undefined | void;
// (undocumented)
isIncrementalResult: (result: ApolloLink.Result<any>) => result is Chunk;
// (undocumented)
prepareRequest: (request: ApolloLink.Request) => ApolloLink.Request;
// (undocumented)
startRequest: <TData extends Record<string, unknown>>(request: {
query: DocumentNode;
}) => IncrementalRequest<Chunk, TData>;
}
// (undocumented)
export interface IncrementalRequest<Chunk extends Record<string, unknown>, TData> {
// (undocumented)
handle: (cacheData: TData | DeepPartial<TData> | undefined | null, chunk: Chunk) => FormattedExecutionResult<TData>;
// (undocumented)
hasNext: boolean;
}
// (undocumented)
export type Path = ReadonlyArray<string | number>;
// @internal @deprecated (undocumented)
export interface StreamFieldInfo {
// (undocumented)
isFirstChunk: boolean;
// (undocumented)
isLastChunk: boolean;
}
}
// @public (undocumented)
class IncrementalRequest<TData> implements Incremental.IncrementalRequest<GraphQL17Alpha9Handler.Chunk<TData>, TData> {
// (undocumented)
handle(cacheData: TData | DeepPartial<TData> | null | undefined, chunk: GraphQL17Alpha9Handler.Chunk<TData>): FormattedExecutionResult<TData>;
// (undocumented)
hasNext: boolean;
}
// @public (undocumented)
export namespace NotImplementedHandler {
// (undocumented)
export interface NotImplementedResult extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
arg2: unknown;
// (undocumented)
return: never;
}
// (undocumented)
export interface TypeOverrides {
// (undocumented)
AdditionalApolloLinkResultTypes: NotImplementedResult;
}
}
// @public (undocumented)
export class NotImplementedHandler implements Incremental.Handler<never> {
// (undocumented)
extractErrors(): void;
// (undocumented)
isIncrementalResult(_: any): _ is never;
// (undocumented)
prepareRequest(request: ApolloLink.Request): ApolloLink.Request;
// (undocumented)
startRequest: any;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link.api.md
================================================
## 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 { ApolloClient } from '@apollo/client';
import type { ApplyHKTImplementationWithDefault } from '@apollo/client/utilities/internal';
import type { DefaultContext } from '@apollo/client';
import { DocumentNode } from 'graphql';
import type { FormattedExecutionResult } from 'graphql';
import type { GraphQLFormattedError } from 'graphql';
import type { NotImplementedHandler } from '@apollo/client/incremental';
import type { Observable } from 'rxjs';
import type { OperationTypeNode } from 'graphql';
import type { OperationVariables } from '@apollo/client';
import type { TypeOverrides } from '@apollo/client';
// @public (undocumented)
export namespace ApolloLink {
// (undocumented)
export type AdditionalResultTypes<TData = Record<string, any>, TExtensions = Record<string, any>> = ApplyHKTImplementationWithDefault<TypeOverrides, "AdditionalApolloLinkResultTypes", NotImplementedHandler.TypeOverrides, TData, TExtensions>;
// (undocumented)
export namespace DocumentationTypes {
export function ForwardFunction(operation: ApolloLink.Operation): Observable<ApolloLink.Result>;
export function RequestHandler(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
}
export interface ExecuteContext {
client: ApolloClient;
}
export type ForwardFunction = (operation: ApolloLink.Operation) => Observable<ApolloLink.Result>;
export interface Operation {
readonly client: ApolloClient;
extensions: Record<string, any>;
getContext: () => Readonly<ApolloLink.OperationContext>;
operationName: string | undefined;
operationType: OperationTypeNode;
query: DocumentNode;
setContext: {
(context: Partial<ApolloLink.OperationContext>): void;
(updateContext: (previousContext: Readonly<ApolloLink.OperationContext>) => Partial<ApolloLink.OperationContext>): void;
};
variables: OperationVariables;
}
export interface OperationContext extends DefaultContext {
}
export interface Request {
context?: DefaultContext;
extensions?: Record<string, any>;
query: DocumentNode;
variables?: OperationVariables;
}
export type RequestHandler = (operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction) => Observable<ApolloLink.Result>;
// (undocumented)
export type Result<TData = Record<string, any>, TExtensions = Record<string, any>> = FormattedExecutionResult<TData, TExtensions> | AdditionalResultTypes<TData, TExtensions>;
}
// @public
export class ApolloLink {
constructor(request?: ApolloLink.RequestHandler);
// @deprecated
static concat(...links: ApolloLink[]): ApolloLink;
concat(...links: ApolloLink[]): ApolloLink;
static empty(): ApolloLink;
static execute(link: ApolloLink, request: ApolloLink.Request, context: ApolloLink.ExecuteContext): Observable<ApolloLink.Result>;
static from(links: ApolloLink[]): ApolloLink;
// @internal @deprecated
getMemoryInternals?: () => unknown;
// @internal @deprecated
readonly left?: ApolloLink;
request(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
// @internal @deprecated
readonly right?: ApolloLink;
static split(test: (op: ApolloLink.Operation) => boolean, left: ApolloLink, right?: ApolloLink): ApolloLink;
split(test: (op: ApolloLink.Operation) => boolean, left: ApolloLink, right?: ApolloLink): ApolloLink;
}
// @public (undocumented)
export interface ApolloPayloadResult<TData = Record<string, any>, TExtensions = Record<string, any>> {
// (undocumented)
errors?: ReadonlyArray<GraphQLFormattedError>;
// (undocumented)
payload: FormattedExecutionResult<TData, TExtensions> | null;
}
// @public @deprecated (undocumented)
export const concat: typeof ApolloLink.concat;
export { DocumentNode }
// @public @deprecated (undocumented)
export const empty: typeof ApolloLink.empty;
// @public (undocumented)
export const execute: typeof ApolloLink.execute;
// @public @deprecated (undocumented)
export type FetchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ApolloLink.Result<TData, TExtensions>;
// @public @deprecated (undocumented)
export const from: typeof ApolloLink.from;
// @public @deprecated (undocumented)
export type GraphQLRequest = ApolloLink.Request;
// @public @deprecated (undocumented)
export type Operation = ApolloLink.Operation;
// @public @deprecated (undocumented)
export type RequestHandler = ApolloLink.RequestHandler;
// @public @deprecated (undocumented)
export const split: typeof ApolloLink.split;
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_batch-http.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { BaseHttpLink } from '@apollo/client/link/http';
import { BatchLink } from '@apollo/client/link/batch';
import { ClientAwarenessLink } from '@apollo/client/link/client-awareness';
import { Observable } from 'rxjs';
// @public (undocumented)
export namespace BaseBatchHttpLink {
export interface ContextOptions extends BaseHttpLink.ContextOptions {
}
export interface Options extends BatchLink.Shared.Options, BaseHttpLink.Shared.Options {
batchMax?: number;
}
}
// @public
export class BaseBatchHttpLink extends ApolloLink {
constructor(options?: BaseBatchHttpLink.Options);
// (undocumented)
request(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
}
// @public (undocumented)
export namespace BatchHttpLink {
export interface ContextOptions extends BaseBatchHttpLink.ContextOptions, ClientAwarenessLink.ContextOptions {
}
export interface Options extends BaseBatchHttpLink.Options, ClientAwarenessLink.Options {
}
}
// @public
export class BatchHttpLink extends ApolloLink {
constructor(options?: BatchHttpLink.Options);
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_batch.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { Observable } from 'rxjs';
// @public (undocumented)
export namespace BatchLink {
export type BatchHandler = (operations: ApolloLink.Operation[], forward: ApolloLink.ForwardFunction[]) => Observable<ApolloLink.Result[]>;
export interface Options extends Shared.Options {
batchHandler?: BatchLink.BatchHandler;
batchMax?: number;
}
// (undocumented)
export namespace Shared {
export interface Options {
batchDebounce?: boolean;
batchInterval?: number;
batchKey?: (operation: ApolloLink.Operation) => string;
batchMax?: number;
}
}
}
// @public
export class BatchLink extends ApolloLink {
constructor(options?: BatchLink.Options);
// (undocumented)
request(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_client-awareness.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
// @public (undocumented)
export namespace ClientAwarenessLink {
// (undocumented)
export interface ClientAwarenessOptions {
name?: string;
transport?: "headers" | false;
version?: string;
}
export interface ContextOptions {
clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
}
// (undocumented)
export interface EnhancedClientAwarenessOptions {
transport?: "headers" | "extensions" | false;
}
// (undocumented)
export interface Options {
clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
}
}
// @public
export class ClientAwarenessLink extends ApolloLink {
constructor(options?: ClientAwarenessLink.Options);
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_context.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
// @public @deprecated (undocumented)
export function setContext(setter: SetContextLink.LegacyContextSetter): SetContextLink;
// @public (undocumented)
export namespace SetContextLink {
export type ContextSetter = (prevContext: Readonly<ApolloLink.OperationContext>, operation: SetContextLink.SetContextOperation) => Promise<Partial<ApolloLink.OperationContext>> | Partial<ApolloLink.OperationContext>;
// @deprecated (undocumented)
export type LegacyContextSetter = (operation: SetContextLink.SetContextOperation, prevContext: Readonly<ApolloLink.OperationContext>) => Promise<Partial<ApolloLink.OperationContext>> | Partial<ApolloLink.OperationContext>;
// (undocumented)
export namespace SetContextLinkDocumentationTypes {
export function ContextSetter(prevContext: Readonly<ApolloLink.OperationContext>, operation: SetContextLink.SetContextOperation): Promise<Partial<ApolloLink.OperationContext>> | Partial<ApolloLink.OperationContext>;
}
export type SetContextOperation = Omit<ApolloLink.Operation, "getContext" | "setContext">;
}
// @public
export class SetContextLink extends ApolloLink {
constructor(setter: SetContextLink.ContextSetter);
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_error.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { ErrorLike } from '@apollo/client';
import { Observable } from 'rxjs';
// @public (undocumented)
export namespace ErrorLink {
export interface ErrorHandler {
// (undocumented)
(options: ErrorHandlerOptions): Observable<ApolloLink.Result> | void;
}
export interface ErrorHandlerOptions {
error: ErrorLike;
forward: ApolloLink.ForwardFunction;
operation: ApolloLink.Operation;
result?: ApolloLink.Result;
}
// (undocumented)
export namespace ErrorLinkDocumentationTypes {
export function ErrorHandler(options: ErrorHandlerOptions): Observable<ApolloLink.Result> | void;
}
}
// @public
export class ErrorLink extends ApolloLink {
constructor(errorHandler: ErrorLink.ErrorHandler);
}
// @public @deprecated (undocumented)
export function onError(errorHandler: ErrorLink.ErrorHandler): ErrorLink;
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_http.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { ASTNode } from 'graphql';
import { ClientAwarenessLink } from '@apollo/client/link/client-awareness';
import type { print as print_2 } from 'graphql';
// @public (undocumented)
export namespace BaseHttpLink {
// (undocumented)
export interface Body {
// (undocumented)
extensions?: Record<string, any>;
// (undocumented)
operationName?: string;
// (undocumented)
query?: string;
// (undocumented)
variables?: Record<string, any>;
}
export interface ContextOptions {
credentials?: RequestCredentials;
fetchOptions?: RequestInit;
headers?: Record<string, string>;
http?: BaseHttpLink.HttpOptions;
uri?: string | BaseHttpLink.UriFunction;
}
export interface HttpOptions {
accept?: string[];
includeExtensions?: boolean;
includeQuery?: boolean;
preserveHeaderCase?: boolean;
}
export interface Options extends Shared.Options {
useGETForQueries?: boolean;
}
// (undocumented)
export type Printer = (node: ASTNode, originalPrint: typeof print_2) => string;
// (undocumented)
export namespace Shared {
export interface Options {
credentials?: RequestCredentials;
fetch?: typeof fetch;
fetchOptions?: RequestInit;
headers?: Record<string, string>;
includeExtensions?: boolean;
includeUnusedVariables?: boolean;
preserveHeaderCase?: boolean;
print?: BaseHttpLink.Printer;
uri?: string | BaseHttpLink.UriFunction;
}
}
// (undocumented)
export type UriFunction = (operation: ApolloLink.Operation) => string;
}
// @public
export class BaseHttpLink extends ApolloLink {
constructor(options?: BaseHttpLink.Options);
}
// @public (undocumented)
export const checkFetcher: (fetcher: typeof fetch | undefined) => void;
// @public @deprecated (undocumented)
export const createHttpLink: (options?: HttpLink.Options) => HttpLink;
// @public @deprecated (undocumented)
export const createSignalIfSupported: () => {
controller: boolean;
signal: boolean;
} | {
controller: AbortController;
signal: AbortSignal;
};
// @public (undocumented)
export const defaultPrinter: BaseHttpLink.Printer;
// @public (undocumented)
export const fallbackHttpConfig: {
http: BaseHttpLink.HttpOptions;
headers: {
accept: string;
"content-type": string;
};
options: {
method: string;
};
};
// @public (undocumented)
interface HttpConfig {
// (undocumented)
credentials?: any;
// (undocumented)
headers?: Record<string, string>;
// (undocumented)
http?: BaseHttpLink.HttpOptions;
// (undocumented)
options?: any;
}
// @public (undocumented)
export namespace HttpLink {
export interface ContextOptions extends BaseHttpLink.ContextOptions, ClientAwarenessLink.ContextOptions {
}
export interface Options extends BaseHttpLink.Options, ClientAwarenessLink.Options {
}
}
// @public
export class HttpLink extends ApolloLink {
constructor(options?: HttpLink.Options);
}
// @public (undocumented)
export function parseAndCheckHttpResponse(operations: ApolloLink.Operation | ApolloLink.Operation[]): (response: Response) => Promise<any>;
// @public (undocumented)
export function rewriteURIForGET(chosenURI: string, body: BaseHttpLink.Body): {
parseError: unknown;
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: ApolloLink.Operation, fallbackConfig: HttpConfig, ...configs: Array<HttpConfig>): {
options: HttpConfig & Record<string, any>;
body: BaseHttpLink.Body;
};
// @public (undocumented)
export function selectHttpOptionsAndBodyInternal(operation: ApolloLink.Operation, printer: BaseHttpLink.Printer, ...configs: HttpConfig[]): {
options: HttpConfig & Record<string, any>;
body: BaseHttpLink.Body;
};
// @public (undocumented)
export const selectURI: (operation: ApolloLink.Operation, fallbackURI?: string | ((operation: ApolloLink.Operation) => string)) => any;
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_persisted-queries.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { DocumentNode } from 'graphql';
import type { ErrorLike } from '@apollo/client';
import type { FormattedExecutionResult } from 'graphql';
// @public @deprecated (undocumented)
export const createPersistedQueryLink: (options: PersistedQueryLink.Options) => PersistedQueryLink;
// @public (undocumented)
export namespace PersistedQueryLink {
// (undocumented)
export namespace Base {
export interface Options {
disable?: (options: PersistedQueryLink.DisableFunctionOptions) => boolean;
retry?: (options: PersistedQueryLink.RetryFunctionOptions) => boolean;
useGETForHashedQueries?: boolean;
}
}
export interface DisableFunctionOptions extends PersistedQueryLink.RetryFunctionOptions {
}
export interface ErrorMeta {
persistedQueryNotFound: boolean;
persistedQueryNotSupported: boolean;
}
export type GenerateHashFunction = (document: DocumentNode) => string | PromiseLike<string>;
export interface GenerateHashOptions extends Base.Options {
generateHash: PersistedQueryLink.GenerateHashFunction;
// (undocumented)
sha256?: never;
}
export type Options = PersistedQueryLink.SHA256Options | PersistedQueryLink.GenerateHashOptions;
// (undocumented)
export namespace PersistedQueryLinkDocumentationTypes {
export function GenerateHashFunction(document: DocumentNode): string | PromiseLike<string>;
export function SHA256Function(queryString: string): string | PromiseLike<string>;
}
export interface RetryFunctionOptions {
error: ErrorLike;
meta: PersistedQueryLink.ErrorMeta;
operation: ApolloLink.Operation;
result?: FormattedExecutionResult;
}
export type SHA256Function = (queryString: string) => string | PromiseLike<string>;
export interface SHA256Options extends Base.Options {
// (undocumented)
generateHash?: never;
sha256: PersistedQueryLink.SHA256Function;
}
}
// @public
export class PersistedQueryLink extends ApolloLink {
constructor(options: PersistedQueryLink.Options);
// (undocumented)
resetHashCache: () => void;
}
// @public (undocumented)
export const VERSION = 1;
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_remove-typename.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
// @public
export const KEEP = "__KEEP";
// @public @deprecated (undocumented)
export function removeTypenameFromVariables(options?: RemoveTypenameFromVariablesLink.Options): RemoveTypenameFromVariablesLink;
// @public (undocumented)
export namespace RemoveTypenameFromVariablesLink {
export interface KeepTypenameConfig {
// (undocumented)
[key: string]: typeof KEEP | RemoveTypenameFromVariablesLink.KeepTypenameConfig;
}
export interface Options {
except?: RemoveTypenameFromVariablesLink.KeepTypenameConfig;
}
}
// @public
export class RemoveTypenameFromVariablesLink extends ApolloLink {
constructor(options?: RemoveTypenameFromVariablesLink.Options);
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_retry.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { ErrorLike } from '@apollo/client';
import { Observable } from 'rxjs';
// @public (undocumented)
export namespace RetryLink {
export type AttemptsFunction = (attempt: number, operation: ApolloLink.Operation, error: ErrorLike) => boolean | Promise<boolean>;
export interface AttemptsOptions {
max?: number;
retryIf?: (error: ErrorLike, operation: ApolloLink.Operation) => boolean | Promise<boolean>;
}
export type DelayFunction = (attempt: number, operation: ApolloLink.Operation, error: ErrorLike) => number;
export interface DelayOptions {
initial?: number;
jitter?: boolean;
max?: number;
}
export interface Options {
attempts?: RetryLink.AttemptsOptions | RetryLink.AttemptsFunction;
delay?: RetryLink.DelayOptions | RetryLink.DelayFunction;
}
// (undocumented)
export namespace RetryLinkDocumentationTypes {
export function AttemptsFunction(attempt: number, operation: ApolloLink.Operation, error: ErrorLike): boolean | Promise<boolean>;
export function DelayFunction(attempt: number, operation: ApolloLink.Operation, error: ErrorLike): number;
}
}
// @public
export class RetryLink extends ApolloLink {
constructor(options?: RetryLink.Options);
// (undocumented)
request(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_schema.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { GraphQLSchema } from 'graphql';
import { Observable } from 'rxjs';
// @public (undocumented)
export namespace SchemaLink {
export interface Options {
context?: SchemaLink.ResolverContext | SchemaLink.ResolverContextFunction;
rootValue?: any;
schema: GraphQLSchema;
validate?: boolean;
}
export type ResolverContext = Record<string, any>;
export type ResolverContextFunction = (operation: ApolloLink.Operation) => SchemaLink.ResolverContext | PromiseLike<SchemaLink.ResolverContext>;
// (undocumented)
export namespace SchemaLinkDocumentationTypes {
export function ResolverContextFunction(operation: ApolloLink.Operation): SchemaLink.ResolverContext | PromiseLike<SchemaLink.ResolverContext>;
}
}
// @public
export class SchemaLink extends ApolloLink {
constructor(options: SchemaLink.Options);
// (undocumented)
context: SchemaLink.Options["context"];
// (undocumented)
request(operation: ApolloLink.Operation): Observable<ApolloLink.Result>;
// (undocumented)
rootValue: SchemaLink.Options["rootValue"];
// (undocumented)
schema: SchemaLink.Options["schema"];
// (undocumented)
validate: boolean;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_subscriptions.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { Client } from 'graphql-ws';
import { Observable } from 'rxjs';
// @public
export class GraphQLWsLink extends ApolloLink {
constructor(client: Client);
// (undocumented)
readonly client: Client;
// (undocumented)
request(operation: ApolloLink.Operation): Observable<ApolloLink.Result>;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_utils.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { DocumentNode } from 'graphql';
// @public (undocumented)
export function createOperation(request: ApolloLink.Request, { client }: ApolloLink.ExecuteContext): ApolloLink.Operation;
// @public (undocumented)
export function filterOperationVariables(variables: Record<string, any>, query: DocumentNode): {
[x: string]: any;
};
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-link_ws.api.md
================================================
## 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 { ApolloLink } from '@apollo/client/link';
import type { ClientOptions } from 'subscriptions-transport-ws';
import type { Observable } from 'rxjs';
import { SubscriptionClient } from 'subscriptions-transport-ws';
// @public (undocumented)
export namespace WebSocketLink {
export interface Configuration {
options?: ClientOptions;
uri: string;
webSocketImpl?: any;
}
}
// @public @deprecated
export class WebSocketLink extends ApolloLink {
constructor(paramsOrClient: WebSocketLink.Configuration | SubscriptionClient);
// (undocumented)
request(operation: ApolloLink.Operation): Observable<ApolloLink.Result>;
}
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-local-state.api.md
================================================
## 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 { ApolloClient } from '@apollo/client';
import type { DefaultContext } from '@apollo/client';
import type { DocumentNode } from 'graphql';
import type { FieldNode } from 'graphql';
import type { FormattedExecutionResult } from 'graphql';
import type { FragmentMap } from '@apollo/client/utilities/internal';
import type { NoInfer as NoInfer_2 } from '@apollo/client/utilities/internal';
import type { OperationVariables } from '@apollo/client';
import type { RemoveIndexSignature } from '@apollo/client/utilities/internal';
import type { TypedDocumentNode } from '@apollo/client';
import type { WatchQueryFetchPolicy } from '@apollo/client';
// @public (undocumented)
type InferContextValueFromResolvers<TResolvers> = TResolvers extends {
[typename: string]: infer TFieldResolvers;
} ? TFieldResolvers extends ({
[field: string]: LocalState.Resolver<any, any, infer TContext, any>;
}) ? unknown extends TContext ? DefaultContext : TContext : DefaultContext : DefaultContext;
// @public (undocumented)
export namespace LocalState {
// (undocumented)
export type ContextFunction<TContext> = (options: ContextFunctionOptions) => TContext;
// (undocumented)
export interface ContextFunctionOptions {
// (undocumented)
client: ApolloClient;
// (undocumented)
document: DocumentNode;
// (undocumented)
phase: "exports" | "resolve";
// (undocumented)
requestContext: DefaultContext;
// (undocumented)
variables: OperationVariables;
}
// Warning: (ae-forgotten-export) The symbol "MaybeRequireContextFunction" needs to be exported by the entry point index.d.ts
export type Options<TResolvers extends Resolvers = Resolvers, TContext = DefaultContext> = {
context?: ContextFunction<TContext>;
resolvers?: TResolvers;
} & MaybeRequireContextFunction<TContext>;
// (undocumented)
export type Path = Array<string | number>;
export type Resolver<TResult = unknown, TParent = unknown, TContext = DefaultContext, TArgs = Record<string, unknown>> = (rootValue: TParent, args: TArgs, context: {
requestContext: TContext;
client: ApolloClient;
phase: "exports" | "resolve";
}, info: {
field: FieldNode;
fragmentMap: FragmentMap;
path: Path;
}) => TResult | Promise<TResult>;
export interface Resolvers<TContext = any> {
// (undocumented)
[typename: string]: {
[field: string]: Resolver<any, any, TContext, any>;
};
}
// (undocumented)
export type RootValueFunction<TRootValue> = (context: RootValueFunctionContext) => TRootValue;
// (undocumented)
export interface RootValueFunctionContext {
// (undocumented)
client: ApolloClient;
// (undocumented)
context: DefaultContext;
// (undocumented)
document: DocumentNode;
// (undocumented)
phase: "exports" | "resolve";
// (undocumented)
variables: OperationVariables;
}
}
// Warning: (ae-forgotten-export) The symbol "InferContextValueFromResolvers" needs to be exported by the entry point index.d.ts
//
// @public
export class LocalState<TResolvers extends LocalState.Resolvers = LocalState.Resolvers<DefaultContext>, TContext = InferContextValueFromResolvers<TResolvers>> {
constructor(...[options]: {} extends TResolvers ? [
options?: LocalState.Options<TResolvers, NoInfer_2<TContext>>
] : [
options: LocalState.Options<TResolvers, NoInfer_2<TContext>> & {
resolvers: TResolvers;
}
]);
addResolvers(resolvers: TResolvers): void;
// (undocumented)
execute<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ document, client, context, remoteResult, variables, onlyRunForcedResolvers, returnPartialData, fetchPolicy, }: {
document: DocumentNode | TypedDocumentNode<TData, TVariables>;
client: ApolloClient;
context: DefaultContext | undefined;
remoteResult: FormattedExecutionResult<any> | undefined;
variables: TVariables | undefined;
onlyRunForcedResolvers?: boolean;
returnPartialData?: boolean;
fetchPolicy: WatchQueryFetchPolicy;
}): Promise<FormattedExecutionResult<TData>>;
// (undocumented)
getExportedVariables<TVariables extends OperationVariables = OperationVariables>({ document, client, context, variables, }: {
document: DocumentNode | TypedDocumentNode<any, TVariables>;
client: ApolloClient;
context: DefaultContext | undefined;
variables: Partial<NoInfer_2<TVariables>>;
}): Promise<TVariables>;
}
// @public (undocumented)
type MaybeRequireContextFunction<TContext> = {} extends RemoveIndexSignature<TContext> ? {} : {
context: LocalState.ContextFunction<TContext>;
};
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-masking.api.md
================================================
## 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 { ApolloCache } from '@apollo/client';
import type { ApplyHKTImplementationWithDefault } from '@apollo/client/utilities/internal';
import type { DocumentNode } from '@apollo/client';
import type { DocumentTypeDecoration } from '@graphql-typed-document-node/core';
import type { HKT } from '@apollo/client/utilities';
import type { IsAny } from '@apollo/client/utilities/internal';
import type { Prettify } from '@apollo/client/utilities/internal';
import type { Primitive } from '@apollo/client/utilities/internal';
import type { RemoveIndexSignature } from '@apollo/client/utilities/internal';
import type { TypedDocumentNode } from '@apollo/client';
import type { TypeOverrides } from '@apollo/client';
// Warning: (ae-forgotten-export) The symbol "MergeUnions" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "ExtractByMatchingTypeNames" needs to be exported by the entry point index.d.ts
//
// @public
type CombineByTypeName<T extends {
__typename?: string;
}> = {
[TypeName in NonNullable<T["__typename"]>]: Prettify<MergeUnions<ExtractByMatchingTypeNames<T, TypeName>>>;
}[NonNullable<T["__typename"]>];
// Warning: (ae-forgotten-export) The symbol "CombineByTypeName" needs to be exported by the entry point index.d.ts
//
// @public
type CombineIntersection<T> = Exclude<T, {
__typename?: string;
}> | CombineByTypeName<Extract<T, {
__typename?: string;
}>>;
// Warning: (ae-forgotten-export) The symbol "Exact" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type ContainsFragmentsRefs<TData, Seen = never> = true extends (IsAny<TData>) ? false : TData extends object ? Exact<TData> extends Seen ? false : " $fragmentRefs" extends keyof RemoveIndexSignature<TData> ? true : ContainsFragmentsRefs<TData[keyof TData], Seen | Exact<TData>> : false;
// @internal @deprecated (undocumented)
export const disableWarningsSlot: {
readonly id: string;
hasValue(): boolean;
getValue(): boolean | undefined;
withValue<TResult, TArgs extends any[], TThis = any>(value: boolean, callback: (this: TThis, ...args: TArgs) => TResult, args?: TArgs | undefined, thisArg?: TThis | undefined): TResult;
};
// @public (undocumented)
type DistributedRequiredExclude<T, U> = T extends any ? Required<T> extends Required<U> ? Required<U> extends Required<T> ? never : T : T : T;
// @public (undocumented)
type Exact<in out T> = (x: T) => T;
// @public
type ExtractByMatchingTypeNames<Union extends {
__typename?: string;
}, TypeName extends string> = Union extends any ? TypeName extends NonNullable<Union["__typename"]> ? Omit<Union, "__typename"> & {
[K in keyof Union as K extends "__typename" ? K : never]: TypeName;
} : never : never;
// Warning: (ae-forgotten-export) The symbol "PreserveTypes" needs to be exported by the entry point index.d.ts
//
// @public
export type FragmentType<TFragmentDataOrTypedDocumentNode> = ApplyHKTImplementationWithDefault<TypeOverrides, "FragmentType", PreserveTypes.TypeOverrides, TFragmentDataOrTypedDocumentNode extends (DocumentTypeDecoration<infer TFragmentData, any>) ? TFragmentData : TFragmentDataOrTypedDocumentNode>;
// @public (undocumented)
export namespace GraphQLCodegenDataMasking {
// (undocumented)
export type FragmentType<TData> = [
TData
] extends [{
" $fragmentName"?: infer TKey;
}] ? TKey extends string ? {
" $fragmentRefs"?: {
[key in TKey]: TData;
};
} : never : never;
// (undocumented)
export namespace HKTImplementation {
// (undocumented)
export interface FragmentType extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: GraphQLCodegenDataMasking.FragmentType<this["arg1"]>;
}
// (undocumented)
export interface MaybeMasked extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: GraphQLCodegenDataMasking.MaybeMasked<this["arg1"]>;
}
// (undocumented)
export interface Unmasked extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: GraphQLCodegenDataMasking.Unmasked<this["arg1"]>;
}
}
export type MaybeMasked<TData> = TData;
// (undocumented)
export interface TypeOverrides {
// (undocumented)
FragmentType: HKTImplementation.FragmentType;
// (undocumented)
MaybeMasked: HKTImplementation.MaybeMasked;
// (undocumented)
Unmasked: HKTImplementation.Unmasked;
}
// Warning: (ae-forgotten-export) The symbol "ContainsFragmentsRefs" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "UnwrapFragmentRefs" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "RemoveFragmentName" needs to be exported by the entry point index.d.ts
export type Unmasked<TData> = true extends IsAny<TData> ? TData : TData extends object ? true extends ContainsFragmentsRefs<TData> ? UnwrapFragmentRefs<RemoveFragmentName<TData>> : TData : TData;
}
// @internal @deprecated (undocumented)
export function maskFragment<TData = unknown>(data: TData, document: TypedDocumentNode<TData> | DocumentNode, cache: ApolloCache, fragmentName?: string): TData;
// @internal @deprecated (undocumented)
export function maskOperation<TData = unknown>(data: TData, document: DocumentNode | TypedDocumentNode<TData>, cache: ApolloCache): TData;
// @public
export type MaybeMasked<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "MaybeMasked", PreserveTypes.TypeOverrides, TData>;
// Warning: (ae-forgotten-export) The symbol "CombineIntersection" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type MergeObjects<T, U> = Prettify<{
[k in keyof T]: k extends keyof U ? [
NonNullable<T[k]>,
NonNullable<U[k]>
] extends ([
infer TK extends object,
infer UK extends object
]) ? TK extends unknown[] ? UK extends unknown[] ? CombineIntersection<TK[number] | UK[number]>[] | Extract<T[k] | U[k], undefined | null> : T[k] : CombineIntersection<TK | UK> | Extract<T[k] | U[k], undefined | null> : T[k] : T[k];
} & Pick<U, Exclude<keyof U, keyof T>>>;
// Warning: (ae-forgotten-export) The symbol "MergeUnionsAcc" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "takeOneFromUnion" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type MergeUnions<TUnion> = MergeUnionsAcc<TUnion, takeOneFromUnion<TUnion>, never>;
// Warning: (ae-forgotten-export) The symbol "DistributedRequiredExclude" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "MergeObjects" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type MergeUnionsAcc<TUnion, Curr, Merged> = [
Curr
] extends [never] ? Merged : MergeUnionsAcc<DistributedRequiredExclude<TUnion, Curr>, takeOneFromUnion<DistributedRequiredExclude<TUnion, Curr>>, [
Merged
] extends [never] ? Curr : MergeObjects<Curr, Merged>>;
// @public (undocumented)
namespace PreserveTypes {
// (undocumented)
type FragmentType<_TData> = never;
// (undocumented)
namespace HKTImplementation {
// (undocumented)
interface FragmentType extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: never;
}
// (undocumented)
interface MaybeMasked extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: this["arg1"];
}
// (undocumented)
interface Unmasked extends HKT {
// (undocumented)
arg1: unknown;
// (undocumented)
return: this["arg1"];
}
}
// (undocumented)
type MaybeMasked<TData> = TData;
// (undocumented)
interface TypeOverrides {
// Warning: (ae-forgotten-export) The symbol "PreserveTypes" needs to be exported by the entry point index.d.ts
//
// (undocumented)
FragmentType: HKTImplementation.FragmentType;
// (undocumented)
MaybeMasked: HKTImplementation.MaybeMasked;
// (undocumented)
Unmasked: HKTImplementation.Unmasked;
}
// (undocumented)
type Unmasked<TData> = TData;
}
// @public (undocumented)
type RemoveFragmentName<T> = T extends any ? Omit<T, " $fragmentName"> : T;
// Warning: (ae-forgotten-export) The symbol "unionToIntersection" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type takeOneFromUnion<T> = unionToIntersection<T extends T ? (x: T) => 0 : never> extends ((x: infer U) => 0) ? U : never;
// @public (undocumented)
type unionToIntersection<T> = (T extends unknown ? (x: T) => unknown : never) extends ((x: infer U) => unknown) ? U : never;
// @public
export type Unmasked<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Unmasked", PreserveTypes.TypeOverrides, TData>;
// @public (undocumented)
type UnwrapFragmentRefs<TData> = true extends IsAny<TData> ? TData : TData extends any ? TData extends Primitive ? TData : string extends keyof TData ? TData : keyof TData extends never ? TData : TData extends {
" $fragmentRefs"?: infer FragmentRefs;
} ? UnwrapFragmentRefs<CombineIntersection<Omit<TData, " $fragmentRefs"> | RemoveFragmentName<NonNullable<NonNullable<FragmentRefs>[keyof NonNullable<FragmentRefs>]>>>> : TData extends object ? {
[K in keyof TData]: UnwrapFragmentRefs<TData[K]>;
} : TData : never;
// (No @packageDocumentation comment for this package)
```
================================================
FILE: .api-reports/api-report-react.api.md
================================================
## 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 { ApolloCache } from '@apollo/client';
import type { ApolloCache as ApolloCache_2 } from '@apollo/client/cache';
import type { ApolloClient } from '@apollo/client';
import type { DataState } from '@apollo/client';
import type { DataValue } from '@apollo/client';
import type { DefaultContext } from '@apollo/client';
import type { DocumentationTypes } from '@apollo/client/utilities/internal';
import type { DocumentNode } from 'graphql';
import type { DocumentNode as DocumentNode_2 } from '@apollo/client';
import type { ErrorLike } from '@apollo/client';
import type { ErrorPolicy } from '@apollo/client';
import type { FetchMoreFunction } from '@apollo/client/react/internal';
import type { FetchPolicy } from '@apollo/client';
import type { GetDataState } from '@apollo/client';
import type { HookWrappers } from '@apollo/client/react/internal';
import type { IgnoreModifier } from '@apollo/client/cache';
import type { InternalRefetchQueriesInclude } from '@apollo/client';
import type { InternalTypes as InternalTypes_2 } from '@apollo/client';
import type { MaybeMasked } from '@apollo/client';
import type { MaybeMasked as MaybeMasked_2 } from '@apollo/client/masking';
import type { MissingTree } from '@apollo/client/cache';
import type { MutationFetchPolicy } from '@apollo/client';
import type { MutationQueryReducersMap } from '@apollo/client';
import type { MutationUpdaterFunction } from '@apollo/client';
import { NetworkStatus } from '@apollo/client';
import type { NoInfer as NoInfer_2 } from '@apollo/client/utilities/internal';
import type { NormalizedExecutionResult } from '@apollo/client';
import type { ObservableQuery } from '@apollo/client';
import type { OnQueryUpdated } from '@apollo/client';
import type { OperationVariables } from '@apollo/client';
import { PreloadedQueryRef } from '@apollo/client/react/internal';
import type { PreloadedQueryRef as PreloadedQueryRef_2 } from '@apollo/client/react';
import type { Prettify } from '@apollo/client/utilities/internal';
import { QueryRef } from '@apollo/client/react/internal';
import type { QueryRef as QueryRef_2 } from '@apollo/client/react';
import type { ReactiveVar } from '@apollo/client';
import type * as ReactTypes from 'react';
import type { RefetchFunction } from '@apollo/client/react/internal';
import type { RefetchWritePolicy } from '@apollo/client';
import type { SubscribeToMoreFunction } from '@apollo/client';
import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
import type { TypedDocumentNode as TypedDocumentNode_2 } from '@apollo/client';
import type { Unmasked } from '@apollo/client';
import type { UpdateQueryMapFn } from '@apollo/client';
import type { VariablesOption } from '@apollo/client/utilities/internal';
import type { WatchQueryFetchPolicy } from '@apollo/client';
import type { wrapperSymbol } from '@apollo/client/react/internal';
// @public (undocumented)
export interface ApolloContextValue {
// (undocumented)
[wrapperSymbol]?: HookWrappers;
// (undocumented)
client?: ApolloClient;
}
// @public (undocumented)
export namespace ApolloProvider {
// (undocumented)
export interface Props {
// (undocumented)
children: ReactTypes.ReactNode | ReactTypes.ReactNode[] | null;
// (undocumented)
client: ApolloClient;
}
}
// @public (undocumented)
export const ApolloProvider: ReactTypes.FC<ApolloProvider.Props>;
// @public @deprecated (undocumented)
export type BackgroundQueryHookFetchPolicy = useBackgroundQuery.FetchPolicy;
// @public @deprecated (undocumented)
export type BackgroundQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useBackgroundQuery.Options<TVariables>;
// @public
export function createQueryPreloader(client: ApolloClient): PreloadQueryFunction;
// @public (undocumented)
export function getApolloContext(): ReactTypes.Context<ApolloContextValue>;
// @internal @deprecated (undocumented)
export namespace InternalTypes {
export type { HookWrappers };
}
// @public @deprecated (undocumented)
export type LazyQueryExecFunction<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useLazyQuery.ExecFunction<TData, TVariables>;
// @public @deprecated (undocumented)
export type LazyQueryHookExecOptions<TVariables extends OperationVariables = OperationVariables> = useLazyQuery.ExecOptions<TVariables>;
// @public @deprecated (undocumented)
export type LazyQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useLazyQuery.Options<TData, TVariables>;
// @public @deprecated (undocumented)
export type LazyQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useLazyQuery.Result<TData, TVariables>;
// @public @deprecated (undocumented)
export type LazyQueryResultTuple<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useLazyQuery.ResultTuple<TData, TVariables>;
// @public @deprecated (undocumented)
export type LoadableQueryFetchPolicy = useLoadableQuery.FetchPolicy;
// @public @deprecated (undocumented)
export type LoadableQueryHookOptions = useLoadableQuery.Options;
// @public @deprecated (undocumented)
export type LoadQueryFunction<TVariables extends OperationVariables> = useLoadableQuery.LoadQueryFunction<TVariables>;
// @public (undocumented)
type MakeRequiredVariablesOptional<TVariables extends OperationVariables, TConfiguredVariables extends Partial<TVariables>> = Prettify<{
[K in keyof TVariables as K extends keyof TConfiguredVariables ? K : never]?: TVariables[K];
} & Omit<TVariables, keyof TConfiguredVariables>>;
// @public @deprecated (undocumented)
export type MutationFunctionOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, _TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = useMutation.MutationFunctionOptions<TData, TVariables, TCache>;
// @public @deprecated (undocumented)
export type MutationHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, _TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = useMutation.Options<TData, TVariables, TCache>;
// @public @deprecated (undocumented)
export type MutationResult<TData = unknown> = useMutation.Result<TData>;
// @public @deprecated (undocumented)
export type MutationTuple<TData, TVariables extends OperationVariables, _TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = useMutation.ResultTuple<TData, TVariables, TCache>;
// @public @deprecated (undocumented)
export type OnDataOptions<TData = unknown> = useSubscription.OnDataOptions<TData>;
// @public @deprecated (undocumented)
export type OnSubscriptionDataOptions<TData = unknown> = useSubscription.OnSubscriptionDataOptions<TData>;
export { PreloadedQueryRef }
// @public (undocumented)
export type PreloadQueryFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
// @public
export interface PreloadQueryFunction {
<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: PreloadQueryOptions<NoInfer_2<TVariables>> & {
returnPartialData: true;
errorPolicy: "ignore" | "all";
}): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: PreloadQueryOptions<NoInfer_2<TVariables>> & {
errorPolicy: "ignore" | "all";
}): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming" | "empty">;
<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: PreloadQueryOptions<NoInfer_2<TVariables>> & {
returnPartialData: true;
}): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming" | "partial">;
<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: PreloadQueryOptions<NoInfer_2<TVariables>>
] : [options: PreloadQueryOptions<NoInfer_2<TVariables>>]): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming">;
toPromise<TQueryRef extends PreloadedQueryRef_2<any, any, any>>(queryRef: TQueryRef): Promise<TQueryRef>;
}
// @public (undocumented)
export type PreloadQueryOptions<TVariables extends OperationVariables = OperationVariables> = {
context?: DefaultContext;
errorPolicy?: ErrorPolicy;
fetchPolicy?: PreloadQueryFetchPolicy;
returnPartialData?: boolean;
refetchWritePolicy?: RefetchWritePolicy;
} & VariablesOption<TVariables>;
// @public @deprecated (undocumented)
export type QueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useQuery.Options<TData, TVariables>;
export { QueryRef }
// @public @deprecated (undocumented)
export type QueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useQuery.Result<TData, TVariables>;
// @public (undocumented)
export const reactCompilerVersion: string;
// @public (undocumented)
type ResetFunction = () => void;
// @public (undocumented)
export type SkipToken = typeof skipToken;
// @public (undocumented)
export const skipToken: unique symbol;
// @public @deprecated (undocumented)
export type SubscriptionHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useSubscription.Options<TData, TVariables>;
// @public @deprecated (undocumented)
export type SubscriptionResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useSubscription.Result<TData>;
// @public @deprecated (undocumented)
export type SuspenseQueryHookFetchPolicy = useSuspenseQuery.FetchPolicy;
// @public @deprecated (undocumented)
export type SuspenseQueryHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useSuspenseQuery.Options<TVariables>;
// @public (undocumented)
export function useApolloClient(override?: ApolloClient): ApolloClient;
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: boolean;
fetchPolicy: "no-cache";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: false;
errorPolicy: "ignore" | "all";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "empty">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: boolean;
errorPolicy: "ignore" | "all";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial" | "empty">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
errorPolicy: "ignore" | "all";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "empty">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
skip: boolean;
returnPartialData: false;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
skip: boolean;
returnPartialData: boolean;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: false;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: boolean;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
skip: boolean;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken): [undefined, useBackgroundQuery.Result<TData, TVariables>];
// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: false;
})): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
returnPartialData: boolean;
})): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: useBackgroundQuery.Options<NoInfer_2<TVariables>>
] : [options: useBackgroundQuery.Options<NoInfer_2<TVariables>>]): [
QueryRef_2<TData, TVariables, "complete" | "streaming">,
useBackgroundQuery.Result<TData, TVariables>
];
// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: SkipToken | useBackgroundQuery.Options<NoInfer_2<TVariables>>
] : [options: SkipToken | useBackgroundQuery.Options<NoInfer_2<TVariables>>]): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<NoInfer_2<TVariables>>): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
// @public (undocumented)
export namespace useBackgroundQuery {
import _self = useBackgroundQuery;
// (undocumented)
export namespace Base {
// (undocumented)
export interface Options {
client?: ApolloClient;
context?: DefaultContext;
errorPolicy?: ErrorPolicy;
fetchPolicy?: FetchPolicy;
queryKey?: string | number | any[];
refetchWritePolicy?: RefetchWritePolicy;
returnPartialData?: boolean;
// @deprecated
skip?: boolean;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useBackgroundQuery {
// (undocumented)
export interface Options<TVariables extends OperationVariables = OperationVariables> extends Base.Options, DocumentationTypes.VariableOptions<TVariables> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useBackgroundQuery {
// (undocumented)
export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends useBackgroundQuery.Result<TData, TVariables> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<TVariables>): [
QueryRef_2<TData, TVariables> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];
}
// (undocumented)
export type FetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
// (undocumented)
export type Options<TVariables extends OperationVariables = OperationVariables> = Base.Options & VariablesOption<TVariables>;
// (undocumented)
export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
fetchMore: FetchMoreFunction<TData, TVariables>;
refetch: RefetchFunction<TData, TVariables>;
subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
}
}
// @public @deprecated (undocumented)
export type UseBackgroundQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useBackgroundQuery.Result<TData, TVariables>;
// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables> & {
from: Array<useFragment.FromOptionValue<TData>>;
}): useFragment.Result<Array<TData>>;
// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables> & {
from: Array<null>;
}): useFragment.Result<Array<null>>;
// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables> & {
from: Array<useFragment.FromOptionValue<TData> | null>;
}): useFragment.Result<Array<TData | null>>;
// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables>): useFragment.Result<TData>;
// @public (undocumented)
export namespace useFragment {
import _self = useFragment;
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useFragment {
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends useFragment.Options<TData, TVariables> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useFragment {
// (undocumented)
export interface Result<TData> {
// (undocumented)
complete: boolean;
// (undocumented)
data: MaybeMasked_2<TData> | DataValue.Partial<MaybeMasked_2<TData>>;
missing?: MissingTree;
}
}
}
// (undocumented)
export namespace DocumentationTypes {
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, from, fragmentName, variables, optimistic, client, }: useFragment.Options<TData, TVariables>): useFragment.Result<TData>;
}
export type FromOptionValue<TData> = ApolloCache_2.FromOptionValue<TData>;
// (undocumented)
export interface Options<TData, TVariables extends OperationVariables> {
client?: ApolloClient;
fragment: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>;
fragmentName?: string;
from: useFragment.FromOptionValue<TData> | Array<useFragment.FromOptionValue<TData> | null> | null;
optimistic?: boolean;
variables?: NoInfer_2<TVariables>;
}
// (undocumented)
export type Result<TData> = ({
complete: true;
missing?: never;
} & GetDataState<MaybeMasked_2<TData>, "complete">) | {
complete: false;
missing?: MissingTree;
data: TData extends Array<infer TItem> ? Array<DataValue.Partial<TItem> | null> : DataValue.Partial<TData>;
dataState: "partial";
};
}
// @public @deprecated (undocumented)
export type UseFragmentOptions<TData, TVariables extends OperationVariables> = useFragment.Options<TData, TVariables>;
// @public @deprecated (undocumented)
export type UseFragmentResult<TData> = useFragment.Result<TData>;
// @public
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
returnPartialData: true;
}): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
// @public
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
returnPartialData: boolean;
}): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
// @public
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useLazyQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming">;
// @public (undocumented)
export namespace useLazyQuery {
import _self = useLazyQuery;
// (undocumented)
export namespace Base {
// (undocumented)
export interface Result<TData, TVariables extends OperationVariables> {
client: ApolloClient;
error?: ErrorLike;
fetchMore: <TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>) => Promise<ApolloClient.QueryResult<MaybeMasked<TFetchData>>>;
loading: boolean;
networkStatus: NetworkStatus;
observable: ObservableQuery<TData, TVariables>;
previousData?: MaybeMasked<TData>;
refetch: (variables?: Partial<TVariables>) => Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
startPolling: (pollInterval: number) => void;
stopPolling: () => void;
subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
updateQuery: (mapFn: UpdateQueryMapFn<TData, TVariables>) => void;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useLazyQuery {
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends useLazyQuery.Options<TData, TVariables> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useLazyQuery {
// (undocumented)
export interface Result<TData, TVariables extends OperationVariables> extends Base.Result<TData, TVariables>, DocumentationTypes.DataState<TData>, DocumentationTypes.VariableOptions<TVariables> {
called: boolean;
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useLazyQuery {
// (undocumented)
export interface ExecOptions<TVariables extends OperationVariables> extends DocumentationTypes.VariableOptions<TVariables> {
context?: DefaultContext;
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useLazyQuery {
import ResultTuple = _self.ResultTuple;
}
}
// (undocumented)
export namespace DocumentationTypes {
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<TData, TVariables>): useLazyQuery.ResultTuple<TData, TVariables>;
}
// (undocumented)
export type ExecFunction<TData, TVariables extends OperationVariables> = (...args: {} extends TVariables ? [
options?: useLazyQuery.ExecOptions<TVariables>
] : [options: useLazyQuery.ExecOptions<TVariables>]) => ObservableQuery.ResultPromise<ApolloClient.QueryResult<TData>>;
// (undocumented)
export type ExecOptions<TVariables extends OperationVariables = OperationVariables> = {
context?: DefaultContext;
} & VariablesOption<TVariables>;
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
client?: ApolloClient;
errorPolicy?: ErrorPolicy;
fetchPolicy?: WatchQueryFetchPolicy;
nextFetchPolicy?: WatchQueryFetchPolicy | ((this: ApolloClient.WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: InternalTypes_2.NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
notifyOnNetworkStatusChange?: boolean;
pollInterval?: number;
refetchWritePolicy?: RefetchWritePolicy;
returnPartialData?: boolean;
skipPollAttempt?: () => boolean;
}
// (undocumented)
export type Result<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData, TVariables> & (({
called: true;
variables: TVariables;
} & GetDataState<MaybeMasked<TData>, TStates>) | {
called: false;
variables: Partial<TVariables>;
data: undefined;
dataState: "empty";
});
// (undocumented)
export type ResultTuple<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = [
execute: ExecFunction<TData, TVariables>,
result: useLazyQuery.Result<TData, TVariables, TStates>
];
}
// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options & {
returnPartialData: true;
errorPolicy: "ignore" | "all";
}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options & {
errorPolicy: "ignore" | "all";
}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options & {
returnPartialData: true;
}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial">;
// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options?: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming">;
// @public (undocumented)
export namespace useLoadableQuery {
// (undocumented)
export namespace DocumentationTypes {
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables>;
}
// (undocumented)
export type FetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
// (undocumented)
export interface Handlers<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
fetchMore: FetchMoreFunction<TData, TVariables>;
refetch: RefetchFunction<TData, TVariables>;
// Warning: (ae-forgotten-export) The symbol "ResetFunction" needs to be exported by the entry point index.d.ts
reset: ResetFunction;
subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
}
// (undocumented)
export type LoadQueryFunction<TVariables extends OperationVariables> = (...args: {} extends TVariables ? [variables?: TVariables] : [variables: TVariables]) => void;
// (undocumented)
export interface Options {
client?: ApolloClient;
context?: DefaultContext;
errorPolicy?: ErrorPolicy;
fetchPolicy?: FetchPolicy;
queryKey?: string | number | any[];
refetchWritePolicy?: RefetchWritePolicy;
returnPartialData?: boolean;
}
// (undocumented)
export type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = [
loadQuery: LoadQueryFunction<TVariables>,
queryRef: QueryRef_2<TData, TVariables, TStates> | null,
handlers: Handlers<TData, TVariables>
];
}
// @public @deprecated (undocumented)
export type UseLoadableQueryResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useLoadableQuery.Result<TData, TVariables>;
// Warning: (ae-forgotten-export) The symbol "MakeRequiredVariablesOptional" needs to be exported by the entry point index.d.ts
//
// @public
export function useMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TConfiguredVariables extends Partial<TVariables> = {}>(mutation: DocumentNode_2 | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<NoInfer_2<TData>, NoInfer_2<TVariables>, TCache, {
[K in keyof TConfiguredVariables]: K extends keyof TVariables ? TConfiguredVariables[K] : never;
}>): useMutation.ResultTuple<TData, MakeRequiredVariablesOptional<TVariables, TConfiguredVariables>, TCache>;
// @public (undocumented)
export namespace useMutation {
// (undocumented)
export namespace DocumentationTypes {
export function useMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables>(mutation: DocumentNode_2 | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<TData, TVariables>): useMutation.ResultTuple<TData, TVariables>;
}
// (undocumented)
export type MutationFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache = ApolloCache> = (...[options]: {} extends TVariables ? [
options?: MutationFunctionOptions<TData, TVariables, TCache> & {
variables?: TVariables;
}
] : [
options: MutationFunctionOptions<TData, TVariables, TCache> & {
variables: TVariables;
}
]) => Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
// (undocumented)
export type MutationFunctionOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = Options<TData, TVariables, TCache> & {
context?: DefaultContext | ((hookContext: DefaultContext | undefined) => DefaultContext);
};
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TConfiguredVariables extends Partial<TVariables> = Partial<TVariables>> {
awaitRefetchQueries?: boolean;
client?: ApolloClient;
context?: DefaultContext;
errorPolicy?: ErrorPolicy;
fetchPolicy?: MutationFetchPolicy;
keepRootFields?: boolean;
notifyOnNetworkStatusChange?: boolean;
onCompleted?: (data: MaybeMasked<TData>, clientOptions?: Options<TData, TVariables, TCache>) => void;
onError?: (error: ErrorLike, clientOptions?: Options<TData, TVariables, TCache>) => void;
onQueryUpdated?: OnQueryUpdated<any>;
optimisticResponse?: Unmasked<NoInfer_2<TData>> | ((vars: TVariables, { IGNORE }: {
IGNORE: IgnoreModifier;
}) => Unmasked<NoInfer_2<TData>> | IgnoreModifier);
refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
update?: MutationUpdaterFunction<TData, TVariables, TCache>;
updateQueries?: MutationQueryReducersMap<TData>;
variables?: Partial<TVariables> & TConfiguredVariables;
}
// (undocumented)
export interface Result<TData = unknown> {
called: boolean;
client: ApolloClient;
data: MaybeMasked<TData> | null | undefined;
error: ErrorLike | undefined;
loading: boolean;
reset: () => void;
}
// (undocumented)
export type ResultTuple<TData, TVariables extends OperationVariables, TCache extends ApolloCache = ApolloCache> = [
mutate: MutationFunction<TData, TVariables, TCache>,
result: Result<TData>
];
}
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
returnPartialData: true;
}): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
returnPartialData: true;
})): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
returnPartialData: boolean;
}): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
returnPartialData: boolean;
})): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>
] : [options: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming">;
// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: SkipToken | useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>
] : [options: SkipToken | useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming", Partial<TVariables>>;
// @public (undocumented)
export namespace useQuery {
// (undocumented)
export namespace Base {
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
client?: ApolloClient;
context?: DefaultContext;
errorPolicy?: ErrorPolicy;
fetchPolicy?: WatchQueryFetchPolicy;
initialFetchPolicy?: WatchQueryFetchPolicy;
nextFetchPolicy?: WatchQueryFetchPolicy | ((this: ApolloClient.WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: InternalTypes_2.NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
notifyOnNetworkStatusChange?: boolean;
pollInterval?: number;
refetchWritePolicy?: RefetchWritePolicy;
returnPartialData?: boolean;
skip?: boolean;
skipPollAttempt?: () => boolean;
ssr?: boolean;
}
}
// (undocumented)
export namespace Base {
// (undocumented)
export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TReturnVariables extends OperationVariables = TVariables> {
client: ApolloClient;
error?: ErrorLike;
fetchMore: <TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>) => Promise<ApolloClient.QueryResult<MaybeMasked_2<TFetchData>>>;
loading: boolean;
networkStatus: NetworkStatus;
observable: ObservableQuery<TData, TVariables>;
previousData?: MaybeMasked_2<TData>;
refetch: (variables?: Partial<TVariables>) => Promise<ApolloClient.QueryResult<MaybeMasked_2<TData>>>;
startPolling: (pollInterval: number) => void;
stopPolling: () => void;
subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
updateQuery: (mapFn: UpdateQueryMapFn<TData, TVariables>) => void;
variables: TReturnVariables;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useQuery {
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Options<TData, TVariables>, DocumentationTypes.VariableOptions<TVariables> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useQuery {
// (undocumented)
export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Result<TData, TVariables>, DocumentationTypes.DataState<TData> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
}
// (undocumented)
export type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = Base.Options<TData, TVariables> & VariablesOption<TVariables>;
// (undocumented)
export type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"], TReturnVariables extends OperationVariables = TVariables> = Base.Result<TData, TVariables, TReturnVariables> & GetDataState<MaybeMasked_2<TData>, TStates>;
}
// @public (undocumented)
export namespace useQuery {
var // (undocumented)
ssrDisabledResult: ObservableQuery.Result<any, "complete" | "streaming" | "partial" | "empty">;
}
// @public
export function useQueryRefHandlers<TData = unknown, TVariables extends OperationVariables = OperationVariables>(queryRef: QueryRef_2<TData, TVariables, DataState<TData>["dataState"]>): useQueryRefHandlers.Result<TData, TVariables>;
// @public (undocumented)
export namespace useQueryRefHandlers {
// (undocumented)
export namespace DocumentationTypes {
export function useQueryRefHandlers<TData = unknown, TVariables extends OperationVariables = OperationVariables>(queryRef: QueryRef_2<TData, TVariables>): useQueryRefHandlers.Result<TData, TVariables>;
}
// (undocumented)
export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
fetchMore: FetchMoreFunction<TData, TVariables>;
refetch: RefetchFunction<TData, TVariables>;
subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
}
}
// @public @deprecated (undocumented)
export type UseQueryRefHandlersResult<TData = unknown, TVariables extends OperationVariables = OperationVariables> = useQueryRefHandlers.Result<TData, TVariables>;
// @public
export function useReactiveVar<T>(rv: ReactiveVar<T>): T;
// @public
export function useReadQuery<TData, TStates extends DataState<TData>["dataState"]>(queryRef: QueryRef_2<TData, any, TStates>): useReadQuery.Result<TData, TStates>;
// @public (undocumented)
export namespace useReadQuery {
// (undocumented)
export namespace Base {
// (undocumented)
export interface Result<TData = unknown> {
error: ErrorLike | undefined;
networkStatus: NetworkStatus;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useReadQuery {
// (undocumented)
export interface Result<TData = unknown> extends Base.Result<TData>, DocumentationTypes.DataState<TData> {
}
}
export function useReadQuery<TData>(queryRef: QueryRef_2<TData>): useReadQuery.Result<TData>;
}
// (undocumented)
export type Result<TData = unknown, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData> & GetDataState<MaybeMasked_2<TData>, TStates>;
}
// @public @deprecated (undocumented)
export type UseReadQueryResult<TData = unknown> = useReadQuery.Result<TData>;
// @public
export function useSubscription<TData = unknown, TVariables extends OperationVariables = OperationVariables>(subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends (TVariables) ? [
options?: useSubscription.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>
] : [options: useSubscription.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>]): useSubscription.Result<TData>;
// @public (undocumented)
export namespace useSubscription {
import _self = useSubscription;
// (undocumented)
export namespace Base {
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
client?: ApolloClient;
context?: DefaultContext;
errorPolicy?: ErrorPolicy;
extensions?: Record<string, any>;
fetchPolicy?: FetchPolicy;
ignoreResults?: boolean;
onComplete?: () => void;
onData?: (options: OnDataOptions<TData>) => any;
onError?: (error: ErrorLike) => void;
shouldResubscribe?: boolean | ((options: Options<TData, TVariables>) => boolean);
skip?: boolean;
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useSubscription {
// (undocumented)
export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Options<TData, TVariables>, DocumentationTypes.VariableOptions<TVariables> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
// (undocumented)
export namespace useSubscription {
// (undocumented)
export interface Result<TData = unknown> extends useSubscription.Result<TData> {
}
}
}
// (undocumented)
export namespace DocumentationTypes {
export function useSubscription<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options?: useSubscription.Options<TData, TVariables>): useSubscription.Result<TData>;
}
// (undocumented)
export interface OnDataOptions<TData = unknown> {
// (undocumented)
client: ApolloClient;
// (undocumented)
data: OnDataResult<TData>;
}
// (undocumented)
export type OnDataResult<TData = unknown> = Omit<Result<TData>, "restart">;
// (undocumented)
export interface OnSubscriptionDataOptions<TData = unknown> {
// (undocumented)
client: ApolloClient;
// (undocumented)
subscriptionData: OnDataResult<TData>;
}
// (undocumented)
export type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = Base.Options<TData, TVariables> & VariablesOption<TVariables>;
// (undocumented)
export interface Result<TData = unknown> {
data?: MaybeMasked_2<TData>;
error?: ErrorLike;
loading: boolean;
restart: () => void;
}
}
// @public
export function useSuspenseFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
from: Array<useSuspenseFragment.FromOptionValue<TData>>;
}): useSuspenseFragment.Result<Array<TData>>;
// @public
export function useSuspenseFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
from: Array<null>;
}): useSuspenseFragment.Result<Array<null>>;
// @public
export function useSuspenseFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
from: Array<useSuspenseFragment.FromOptionValue<TData> | null>;
}): useSuspenseFragment.Result<Array<TData | null>>;
// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
from: useSuspenseFragment.FromOptionValue<TData>;
}): useSuspenseFragment.Result<TData>;
// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
from: null;
}): useSuspenseFragment.Result<null>;
// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
from: useSuspenseFragment.FromOptionValue<TData> | null;
}): useSuspenseFragment.Result<TData | null>;
// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables>): useSuspenseFragment.Result<TData>;
// @public (undocumented)
export namespace useSuspenseFragment {
import _self = useSuspenseFragment;
// (undocumented)
export namespace Base {
// (undocumented)
export type Options<TData, TVariables extends OperationVariables> = {
fragment: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>;
fragmentName?: string;
gitextract_ribxjpsg/ ├── .api-reports/ │ ├── api-report-cache.api.md │ ├── api-report-core.api.md │ ├── api-report-dev.api.md │ ├── api-report-errors.api.md │ ├── api-report-incremental.api.md │ ├── api-report-link.api.md │ ├── api-report-link_batch-http.api.md │ ├── api-report-link_batch.api.md │ ├── api-report-link_client-awareness.api.md │ ├── api-report-link_context.api.md │ ├── api-report-link_error.api.md │ ├── api-report-link_http.api.md │ ├── api-report-link_persisted-queries.api.md │ ├── api-report-link_remove-typename.api.md │ ├── api-report-link_retry.api.md │ ├── api-report-link_schema.api.md │ ├── api-report-link_subscriptions.api.md │ ├── api-report-link_utils.api.md │ ├── api-report-link_ws.api.md │ ├── api-report-local-state.api.md │ ├── api-report-masking.api.md │ ├── api-report-react.api.md │ ├── api-report-react_compiled.api.md │ ├── api-report-react_internal.api.md │ ├── api-report-react_internal_compiler-runtime.api.md │ ├── api-report-react_ssr.api.md │ ├── api-report-testing.api.md │ ├── api-report-testing_internal.api.md │ ├── api-report-testing_react.api.md │ ├── api-report-utilities.api.md │ ├── api-report-utilities_environment.api.md │ ├── api-report-utilities_internal.api.md │ ├── api-report-utilities_internal_globals.api.md │ ├── api-report-utilities_internal_ponyfills.api.md │ ├── api-report-utilities_invariant.api.md │ ├── api-report-utilities_subscriptions_relay.api.md │ ├── api-report-v4-migration.api.md │ ├── api-report-zz_removals.api.md │ └── api-report.api.md ├── .attw.json ├── .changeset/ │ ├── README.md │ └── config.json ├── .circleci/ │ └── config.yml ├── .claude/ │ ├── commands/ │ │ └── chores.md │ ├── documentation.md │ ├── hooks.md │ └── settings.json ├── .git-blame-ignore-revs ├── .gitattributes ├── .github/ │ ├── CODEOWNERS │ ├── ISSUE_TEMPLATE/ │ │ ├── bug.yml │ │ ├── feature-request.md │ │ └── question-discussion.md │ ├── PULL_REQUEST_TEMPLATE.md │ ├── dependabot.yml │ ├── instructions/ │ │ └── apollo-client.instructions.md │ └── workflows/ │ ├── api-extractor.yml │ ├── arethetypeswrong.yml │ ├── change-prerelease-tag.yml │ ├── cleanup-checks.mjs │ ├── cleanup-checks.yml │ ├── close-stale-issues.yml │ ├── compare-build-output.yml │ ├── copilot-setup-steps.yml │ ├── devtools-errorcodes.yml │ ├── docmodel.yml │ ├── exit-prerelease.yml │ ├── issue-close-user-survey.yml │ ├── knip.yml │ ├── lock.yml │ ├── prerelease.yml │ ├── publish-pr-releases.yml │ ├── release.yml │ ├── scheduled-test-canary.yml │ └── size-limit.yml ├── .gitignore ├── .npmrc ├── .prettierignore ├── .prettierrc ├── .semgrepignore ├── .size-limit.cjs ├── .size-limits.json ├── .vscode/ │ ├── launch.json │ └── settings.json ├── CHANGELOG.md ├── CLAUDE.md ├── COLLABORATORS.md ├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── ROADMAP.md ├── VERSIONING_POLICY.md ├── api-extractor.json ├── codegen/ │ ├── CHANGELOG.md │ ├── local-state/ │ │ ├── config.ts │ │ ├── index.ts │ │ ├── plugin.ts │ │ └── visitor.ts │ ├── package.json │ └── tsconfig.json ├── config/ │ ├── FixJSDOMEnvironment.js │ ├── apiExtractor.ts │ ├── babel.ts │ ├── build.ts │ ├── bundlesize.ts │ ├── compare-build-output-to.sh │ ├── compileTs.ts │ ├── deprecateInternals.ts │ ├── dirname.cjs │ ├── entryPoints.ts │ ├── exports.ts │ ├── helpers.ts │ ├── inlineInheritDoc.ts │ ├── jest/ │ │ └── react-dom-17-client.js │ ├── jest.config.ts │ ├── listImports.ts │ ├── madge.ts │ ├── precheck.ts │ ├── prepareDist.ts │ ├── preserveTsIgnore.ts │ ├── prettier/ │ │ ├── format-jsdoc.js │ │ ├── format-mdx3.js │ │ └── test.ts │ ├── processInvariants.ts │ ├── react-compiler.ts │ ├── schema.package.json.ts │ ├── size-limit/ │ │ ├── index.js │ │ └── package.json │ ├── tsconfig.json │ ├── verifySourceMaps.ts │ └── version.ts ├── docs/ │ ├── README.md │ ├── shared/ │ │ └── MdxProvidedComponents.ts │ ├── source/ │ │ ├── _sidebar.yaml │ │ ├── api/ │ │ │ ├── cache/ │ │ │ │ └── InMemoryCache.mdx │ │ │ ├── core/ │ │ │ │ ├── ApolloClient.mdx │ │ │ │ └── ObservableQuery.mdx │ │ │ ├── errors/ │ │ │ │ ├── CombinedGraphQLErrors.mdx │ │ │ │ ├── CombinedProtocolErrors.mdx │ │ │ │ ├── LinkError.mdx │ │ │ │ ├── LocalStateError.mdx │ │ │ │ ├── ServerError.mdx │ │ │ │ ├── ServerParseError.mdx │ │ │ │ └── UnconventionalError.mdx │ │ │ ├── link/ │ │ │ │ ├── apollo-link-base-batch-http.mdx │ │ │ │ ├── apollo-link-base-http.mdx │ │ │ │ ├── apollo-link-batch-http.mdx │ │ │ │ ├── apollo-link-batch.mdx │ │ │ │ ├── apollo-link-client-awareness.mdx │ │ │ │ ├── apollo-link-context.mdx │ │ │ │ ├── apollo-link-error.mdx │ │ │ │ ├── apollo-link-http.mdx │ │ │ │ ├── apollo-link-persisted-queries.mdx │ │ │ │ ├── apollo-link-remove-typename.mdx │ │ │ │ ├── apollo-link-retry.mdx │ │ │ │ ├── apollo-link-schema.mdx │ │ │ │ ├── apollo-link-subscriptions.mdx │ │ │ │ ├── apollo-link-ws.mdx │ │ │ │ ├── apollo-link.mdx │ │ │ │ ├── community-links.mdx │ │ │ │ └── introduction.mdx │ │ │ └── react/ │ │ │ ├── ApolloProvider.mdx │ │ │ ├── hooks-experimental.mdx │ │ │ ├── hooks.mdx │ │ │ ├── preloading.mdx │ │ │ ├── skipToken.mdx │ │ │ ├── ssr.mdx │ │ │ ├── testing.mdx │ │ │ ├── useApolloClient.mdx │ │ │ ├── useBackgroundQuery.mdx │ │ │ ├── useFragment.mdx │ │ │ ├── useLazyQuery.mdx │ │ │ ├── useLoadableQuery.mdx │ │ │ ├── useMutation.mdx │ │ │ ├── useQuery.mdx │ │ │ ├── useQueryRefHandlers.mdx │ │ │ ├── useReactiveVar.mdx │ │ │ ├── useReadQuery.mdx │ │ │ ├── useSubscription.mdx │ │ │ └── useSuspenseQuery.mdx │ │ ├── caching/ │ │ │ ├── advanced-topics.mdx │ │ │ ├── cache-configuration.mdx │ │ │ ├── cache-field-behavior.mdx │ │ │ ├── cache-interaction.mdx │ │ │ ├── garbage-collection.mdx │ │ │ ├── memory-management.mdx │ │ │ └── overview.mdx │ │ ├── data/ │ │ │ ├── defer.mdx │ │ │ ├── directives.mdx │ │ │ ├── document-transforms.mdx │ │ │ ├── error-handling.mdx │ │ │ ├── file-uploads.mdx │ │ │ ├── fragments.mdx │ │ │ ├── mutations.mdx │ │ │ ├── operation-best-practices.mdx │ │ │ ├── persisted-queries.mdx │ │ │ ├── queries.mdx │ │ │ ├── refetching.mdx │ │ │ ├── subscriptions.mdx │ │ │ ├── suspense.mdx │ │ │ └── typescript.mdx │ │ ├── development-testing/ │ │ │ ├── client-schema-mocking.mdx │ │ │ ├── developer-tooling.mdx │ │ │ ├── graphql-codegen.mdx │ │ │ ├── reducing-bundle-size.mdx │ │ │ ├── schema-driven-testing.mdx │ │ │ └── testing.mdx │ │ ├── get-started.mdx │ │ ├── index.mdx │ │ ├── integrations/ │ │ │ ├── integrations.mdx │ │ │ ├── nextjs.mdx │ │ │ ├── react-native.mdx │ │ │ ├── react-router.mdx │ │ │ ├── tanstack-start.mdx │ │ │ └── webpack.mdx │ │ ├── local-state/ │ │ │ ├── local-resolvers.mdx │ │ │ ├── local-state-management.mdx │ │ │ ├── managing-state-with-field-policies.mdx │ │ │ └── reactive-variables.mdx │ │ ├── migrating/ │ │ │ └── apollo-client-4-migration.mdx │ │ ├── networking/ │ │ │ ├── advanced-http-networking.mdx │ │ │ ├── authentication.mdx │ │ │ └── basic-http-networking.mdx │ │ ├── pagination/ │ │ │ ├── core-api.mdx │ │ │ ├── cursor-based.mdx │ │ │ ├── key-args.mdx │ │ │ ├── offset-based.mdx │ │ │ └── overview.mdx │ │ ├── performance/ │ │ │ ├── babel.mdx │ │ │ ├── optimistic-ui.mdx │ │ │ ├── performance.mdx │ │ │ └── server-side-rendering.mdx │ │ └── why-apollo.mdx │ └── tsconfig.json ├── eslint-local-rules/ │ ├── canonical-references.ts │ ├── fixtures/ │ │ ├── file.ts │ │ ├── react.tsx │ │ └── tsconfig.json │ ├── forbid-act-in-disabled-act-environment.test.ts │ ├── forbid-act-in-disabled-act-environment.ts │ ├── generics.ts │ ├── import-from-export.test.ts │ ├── import-from-export.ts │ ├── index.mjs │ ├── package.json │ ├── require-disable-act-environment.test.ts │ ├── require-disable-act-environment.ts │ ├── require-using-disposable.test.ts │ ├── require-using-disposable.ts │ ├── testSetup.ts │ └── tsconfig.json ├── eslint.config.mjs ├── integration-tests/ │ ├── .gitignore │ ├── .npmrc │ ├── api.har │ ├── browser-esm/ │ │ ├── html/ │ │ │ ├── jsdeliver-esm.html │ │ │ ├── jspm-prepared.html │ │ │ └── unpkg-unmangled.html │ │ ├── package.json │ │ ├── playwright.config.ts │ │ └── tests/ │ │ └── playwright/ │ │ ├── jsdeliver-esm.test.ts │ │ ├── jspm-prepared.test.ts │ │ └── unpkg-unmangled.test.ts │ ├── cra5/ │ │ ├── package.json │ │ ├── playwright.config.ts │ │ ├── public/ │ │ │ └── index.html │ │ ├── src/ │ │ │ ├── App.tsx │ │ │ └── index.tsx │ │ ├── tests/ │ │ │ └── playwright/ │ │ │ └── apollo-client.test.ts │ │ └── tsconfig.json │ ├── empty.har │ ├── next/ │ │ ├── next-env.d.ts │ │ ├── next.config.js │ │ ├── package.json │ │ ├── playwright.config.ts │ │ ├── src/ │ │ │ ├── app/ │ │ │ │ ├── cc/ │ │ │ │ │ ├── ApolloWrapper.tsx │ │ │ │ │ ├── layout.tsx │ │ │ │ │ └── page.tsx │ │ │ │ ├── client.ts │ │ │ │ ├── layout.tsx │ │ │ │ └── page.tsx │ │ │ ├── libs/ │ │ │ │ ├── apolloClient.ts │ │ │ │ └── schemaLink.ts │ │ │ └── pages/ │ │ │ ├── _app.tsx │ │ │ ├── pages-no-ssr.tsx │ │ │ └── pages.tsx │ │ ├── tests/ │ │ │ └── playwright/ │ │ │ └── apollo-client.test.ts │ │ └── tsconfig.json │ ├── node/ │ │ ├── package.json │ │ ├── test-cjs.cjs │ │ ├── test-esm.mjs │ │ └── test-require-esm.cjs │ ├── package.json │ ├── peerdeps-tsc/ │ │ ├── .gitignore │ │ ├── package.json │ │ ├── src/ │ │ │ └── index.ts │ │ └── tsconfig.json │ ├── pnpm-workspace.yaml │ ├── shared/ │ │ ├── fixture.ts │ │ ├── package.json │ │ └── playwright.config.ts │ ├── vite/ │ │ ├── index.html │ │ ├── package.json │ │ ├── playwright.config.ts │ │ ├── src/ │ │ │ ├── ApolloLinkResultType.ts │ │ │ ├── App.tsx │ │ │ ├── enhanceDataStates.ts │ │ │ ├── enhanceMaskingTypes.ts │ │ │ └── main.tsx │ │ ├── tests/ │ │ │ └── playwright/ │ │ │ └── apollo-client.test.ts │ │ ├── tsconfig.json │ │ ├── tsconfig.node.json │ │ └── vite.config.ts │ ├── vite-swc/ │ │ ├── index.html │ │ ├── package.json │ │ ├── playwright.config.ts │ │ ├── src/ │ │ │ ├── App.tsx │ │ │ └── main.tsx │ │ ├── tests/ │ │ │ └── playwright/ │ │ │ └── apollo-client.test.ts │ │ ├── tsconfig.json │ │ ├── tsconfig.node.json │ │ └── vite.config.ts │ └── wrapping-library/ │ ├── package.json │ ├── src/ │ │ └── index.ts │ └── tsconfig.json ├── jsconfig.json ├── knip.config.js ├── package.json ├── patches/ │ ├── @changesets+parse+0.4.0.patch │ ├── @microsoft+api-extractor+7.49.1.patch │ ├── @testing-library+react+16.1.0.patch │ ├── eslint-plugin-testing-library+7.1.1.patch │ ├── graphql-17-alpha9+17.0.0-alpha.9.patch │ ├── optimism+0.18.0.patch │ ├── pretty-format+29.7.0.patch │ └── react-dom-17+17.0.2.patch ├── renovate.json ├── scripts/ │ ├── changesets/ │ │ └── categorized/ │ │ ├── categorize.js │ │ ├── categorized.yaml │ │ └── package.json │ ├── codemods/ │ │ ├── ac2-to-ac3/ │ │ │ ├── README.md │ │ │ ├── examples/ │ │ │ │ ├── client-and-cache.ts │ │ │ │ ├── link-packages.js │ │ │ │ └── react-packages.tsx │ │ │ ├── imports.js │ │ │ └── package.json │ │ ├── ac3-to-ac4/ │ │ │ ├── CHANGELOG.md │ │ │ ├── README.md │ │ │ ├── package.json │ │ │ ├── runLocally.sh │ │ │ ├── src/ │ │ │ │ ├── @types/ │ │ │ │ │ └── jscodeshift.d.ts │ │ │ │ ├── __testfixtures__/ │ │ │ │ │ ├── imports.input.ts │ │ │ │ │ └── imports.output.ts │ │ │ │ ├── __tests__/ │ │ │ │ │ ├── __snapshots__/ │ │ │ │ │ │ ├── exports.test.ts.snap │ │ │ │ │ │ └── removals.test.ts.snap │ │ │ │ │ ├── apolloClientInitialization.test.ts │ │ │ │ │ ├── diffTransform.ts │ │ │ │ │ ├── exports.json │ │ │ │ │ ├── exports.new.json │ │ │ │ │ ├── exports.removed.json │ │ │ │ │ ├── exports.removed.local.json │ │ │ │ │ ├── exports.test.ts │ │ │ │ │ ├── fixtures.test.ts │ │ │ │ │ ├── handleIdentifierRename.test.ts │ │ │ │ │ ├── imports.test.ts │ │ │ │ │ ├── legacyEntryPoints.test.ts │ │ │ │ │ ├── links.test.ts │ │ │ │ │ └── removals.test.ts │ │ │ │ ├── apolloClientInitialization.ts │ │ │ │ ├── cli.ts │ │ │ │ ├── devLoader.js │ │ │ │ ├── imports.ts │ │ │ │ ├── index.ts │ │ │ │ ├── legacyEntrypoints.ts │ │ │ │ ├── links.ts │ │ │ │ ├── removals.ts │ │ │ │ ├── renames.ts │ │ │ │ ├── types.ts │ │ │ │ └── util/ │ │ │ │ ├── callExpressionToNewExpression.ts │ │ │ │ ├── entryPointAliases.ts │ │ │ │ ├── findImportDeclarationFor.ts │ │ │ │ ├── findImportSpecifiersFor.ts │ │ │ │ ├── findOrInsertImport.ts │ │ │ │ ├── findReferences.ts │ │ │ │ ├── getAllExports.ts │ │ │ │ ├── getProperty.ts │ │ │ │ ├── getUnusedIdentifier.ts │ │ │ │ ├── handleIdentiferRename.ts │ │ │ │ ├── handleModuleRename.ts │ │ │ │ ├── monkeyPatchAstTypes.ts │ │ │ │ ├── moveGlobalIdentifierToNamespaceAccess.ts │ │ │ │ ├── pick.ts │ │ │ │ ├── renameGlobalIdentifier.ts │ │ │ │ └── reorderGenericArguments.ts │ │ │ ├── tsconfig.build.json │ │ │ ├── tsconfig.json │ │ │ ├── tsconfig.tests.json │ │ │ └── vitest.config.ts │ │ ├── data-masking/ │ │ │ ├── examples/ │ │ │ │ ├── queries-codegen.ts │ │ │ │ ├── queries-react.tsx │ │ │ │ ├── queries.graphql │ │ │ │ └── queries.ts │ │ │ ├── package.json │ │ │ ├── tsconfig.json │ │ │ └── unmask.ts │ │ └── misc/ │ │ └── mockLinkRejection.ts │ └── memory/ │ ├── README.md │ ├── package.json │ ├── tests.cts │ └── tsconfig.json ├── src/ │ ├── __tests__/ │ │ ├── ApolloClient.ts │ │ ├── __snapshots__/ │ │ │ ├── ApolloClient.ts.snap │ │ │ ├── client.ts.snap │ │ │ ├── exports.ts.snap │ │ │ └── mutationResults.ts.snap │ │ ├── client.ts │ │ ├── dataMasking.ts │ │ ├── exports.ts │ │ ├── fetchMore.ts │ │ ├── graphqlSubscriptions.ts │ │ ├── local-state/ │ │ │ ├── __snapshots__/ │ │ │ │ ├── export.ts.snap │ │ │ │ └── general.ts.snap │ │ │ ├── export.ts │ │ │ ├── general.ts │ │ │ ├── resolvers.ts │ │ │ └── subscriptions.ts │ │ ├── mutationResults.ts │ │ ├── optimistic.ts │ │ ├── refetchQueries.ts │ │ ├── resultCacheCleaning.ts │ │ └── subscribeToMore.ts │ ├── cache/ │ │ ├── core/ │ │ │ ├── __tests__/ │ │ │ │ ├── cache.ts │ │ │ │ └── cache.watchFragment/ │ │ │ │ └── types.test.ts │ │ │ ├── cache.ts │ │ │ └── types/ │ │ │ ├── Cache.ts │ │ │ └── common.ts │ │ ├── deprecated.ts │ │ ├── index.ts │ │ └── inmemory/ │ │ ├── __tests__/ │ │ │ ├── __snapshots__/ │ │ │ │ ├── cache.ts.snap │ │ │ │ ├── entityStore.ts.snap │ │ │ │ ├── fragmentMatcher.ts.snap │ │ │ │ ├── policies.ts.snap │ │ │ │ ├── roundtrip.ts.snap │ │ │ │ └── writeToStore.ts.snap │ │ │ ├── cache.ts │ │ │ ├── cache.writeQuery/ │ │ │ │ └── extensions.test.ts │ │ │ ├── diffAgainstStore.ts │ │ │ ├── entityStore.ts │ │ │ ├── fragmentMatcher.ts │ │ │ ├── fragmentRegistry.ts │ │ │ ├── helpers.ts │ │ │ ├── key-extractor.ts │ │ │ ├── optimistic.ts │ │ │ ├── policies.ts │ │ │ ├── readFromStore.ts │ │ │ ├── recordingCache.ts │ │ │ ├── roundtrip.ts │ │ │ └── writeToStore.ts │ │ ├── entityStore.ts │ │ ├── fragmentRegistry.ts │ │ ├── helpers.ts │ │ ├── inMemoryCache.ts │ │ ├── key-extractor.ts │ │ ├── policies.ts │ │ ├── reactiveVars.ts │ │ ├── readFromStore.ts │ │ ├── types.ts │ │ └── writeToStore.ts │ ├── config/ │ │ └── jest/ │ │ ├── areCombinedGraphQLErrorsEqual.ts │ │ ├── areCombinedProtocolErrorsEqual.ts │ │ ├── areGraphQlErrorsEqual.ts │ │ ├── areLocalStateErrorsEqual.ts │ │ ├── areMissingFieldErrorsEqual.ts │ │ ├── areServerErrorsEqual.ts │ │ ├── areWeakRefsEqual.ts │ │ ├── resolver.ts │ │ └── setup.ts │ ├── core/ │ │ ├── ApolloClient.ts │ │ ├── ObservableQuery.ts │ │ ├── QueryInfo.ts │ │ ├── QueryManager.ts │ │ ├── __tests__/ │ │ │ ├── ApolloClient/ │ │ │ │ ├── general.test.ts │ │ │ │ ├── links.test.ts │ │ │ │ └── multiple-results.test.ts │ │ │ ├── ObservableQuery.ts │ │ │ ├── client.mutate/ │ │ │ │ └── refetchQueries.test.ts │ │ │ ├── client.query/ │ │ │ │ ├── context.ts │ │ │ │ └── defaultOptions.test.ts │ │ │ ├── client.readFragment/ │ │ │ │ └── general.test.ts │ │ │ ├── client.watchFragment/ │ │ │ │ ├── arrays.test.ts │ │ │ │ ├── general.test.ts │ │ │ │ ├── getCurrentResult.test.ts │ │ │ │ └── types.test.ts │ │ │ ├── client.watchQuery/ │ │ │ │ ├── defer20220824.test.ts │ │ │ │ ├── deferGraphQL17Alpha9.test.ts │ │ │ │ ├── streamDefer20220824.test.ts │ │ │ │ └── streamGraphQL17Alpha9.test.ts │ │ │ ├── client.writeFragment/ │ │ │ │ └── general.test.ts │ │ │ ├── client.writeQuery/ │ │ │ │ └── extensions.test.ts │ │ │ └── fetchPolicies.ts │ │ ├── deprecated.ts │ │ ├── index.ts │ │ ├── networkStatus.ts │ │ ├── types.ts │ │ └── watchQueryOptions.ts │ ├── dev/ │ │ ├── index.ts │ │ ├── loadDevMessages.ts │ │ ├── loadErrorMessageHandler.ts │ │ ├── loadErrorMessages.ts │ │ ├── setErrorMessageHandler.ts │ │ └── symbol.ts │ ├── errors/ │ │ ├── CombinedGraphQLErrors.ts │ │ ├── CombinedProtocolErrors.ts │ │ ├── LinkError.ts │ │ ├── LocalStateError.ts │ │ ├── ServerError.ts │ │ ├── ServerParseError.ts │ │ ├── UnconventionalError.ts │ │ ├── __tests__/ │ │ │ ├── CombinedGraphQLErrors.test.ts │ │ │ ├── CombinedProtocolErrors.test.ts │ │ │ ├── LinkError.test.ts │ │ │ └── is.test.ts │ │ ├── index.ts │ │ ├── isErrorLike.ts │ │ └── utils.ts │ ├── incremental/ │ │ ├── handlers/ │ │ │ ├── __tests__/ │ │ │ │ ├── defer20220824/ │ │ │ │ │ ├── defer.test.ts │ │ │ │ │ └── stream.test.ts │ │ │ │ └── graphql17Alpha9/ │ │ │ │ ├── defer.test.ts │ │ │ │ └── stream.test.ts │ │ │ ├── defer20220824.ts │ │ │ ├── graphql17Alpha9.ts │ │ │ └── notImplemented.ts │ │ ├── index.ts │ │ └── types.ts │ ├── invariantErrorCodes.ts │ ├── link/ │ │ ├── batch/ │ │ │ ├── __tests__/ │ │ │ │ └── batchLink.ts │ │ │ ├── batchLink.ts │ │ │ ├── batching.ts │ │ │ └── index.ts │ │ ├── batch-http/ │ │ │ ├── BaseBatchHttpLink.ts │ │ │ ├── __tests__/ │ │ │ │ └── batchHttpLink.ts │ │ │ ├── batchHttpLink.ts │ │ │ └── index.ts │ │ ├── client-awareness/ │ │ │ ├── ClientAwarenessLink.ts │ │ │ ├── __tests__/ │ │ │ │ └── ClientAwarenessLink.test.ts │ │ │ └── index.ts │ │ ├── context/ │ │ │ ├── __tests__/ │ │ │ │ └── index.ts │ │ │ └── index.ts │ │ ├── core/ │ │ │ ├── ApolloLink.ts │ │ │ ├── __tests__/ │ │ │ │ └── ApolloLink.ts │ │ │ ├── concat.ts │ │ │ ├── deprecated.ts │ │ │ ├── empty.ts │ │ │ ├── execute.ts │ │ │ ├── from.ts │ │ │ ├── split.ts │ │ │ └── types.ts │ │ ├── error/ │ │ │ ├── __tests__/ │ │ │ │ └── index.ts │ │ │ └── index.ts │ │ ├── http/ │ │ │ ├── BaseHttpLink.ts │ │ │ ├── HttpLink.ts │ │ │ ├── __tests__/ │ │ │ │ ├── HttpLink.ts │ │ │ │ ├── checkFetcher.ts │ │ │ │ ├── headerNormalization.ts │ │ │ │ ├── helpers.ts │ │ │ │ ├── parseAndCheckHttpResponse.ts │ │ │ │ ├── responseIterator.ts │ │ │ │ ├── responseIteratorNoAsyncIterator.ts │ │ │ │ ├── selectHttpOptionsAndBody.ts │ │ │ │ └── selectURI.ts │ │ │ ├── checkFetcher.ts │ │ │ ├── createSignalIfSupported.ts │ │ │ ├── index.ts │ │ │ ├── parseAndCheckHttpResponse.ts │ │ │ ├── rewriteURIForGET.ts │ │ │ ├── selectHttpOptionsAndBody.ts │ │ │ └── selectURI.ts │ │ ├── index.ts │ │ ├── persisted-queries/ │ │ │ ├── __tests__/ │ │ │ │ ├── persisted-queries.test.ts │ │ │ │ └── react.test.tsx │ │ │ └── index.ts │ │ ├── remove-typename/ │ │ │ ├── __tests__/ │ │ │ │ └── removeTypenameFromVariables.ts │ │ │ ├── index.ts │ │ │ └── removeTypenameFromVariables.ts │ │ ├── retry/ │ │ │ ├── __tests__/ │ │ │ │ ├── delayFunction.ts │ │ │ │ ├── retryFunction.ts │ │ │ │ └── retryLink.ts │ │ │ ├── delayFunction.ts │ │ │ ├── index.ts │ │ │ ├── retryFunction.ts │ │ │ └── retryLink.ts │ │ ├── schema/ │ │ │ ├── __tests__/ │ │ │ │ └── schemaLink.ts │ │ │ └── index.ts │ │ ├── subscriptions/ │ │ │ ├── __tests__/ │ │ │ │ └── graphqlWsLink.ts │ │ │ └── index.ts │ │ ├── utils/ │ │ │ ├── __tests__/ │ │ │ │ └── filterOperationVariables.ts │ │ │ ├── createOperation.ts │ │ │ ├── filterOperationVariables.ts │ │ │ └── index.ts │ │ └── ws/ │ │ ├── __tests__/ │ │ │ └── webSocketLink.ts │ │ └── index.ts │ ├── local-state/ │ │ ├── LocalState.ts │ │ ├── __tests__/ │ │ │ └── LocalState/ │ │ │ ├── aliases.test.ts │ │ │ ├── async.test.ts │ │ │ ├── base.test.ts │ │ │ ├── cache.test.ts │ │ │ ├── context.test.ts │ │ │ ├── errors.test.ts │ │ │ ├── exports.test.ts │ │ │ ├── fixtures/ │ │ │ │ ├── base-types.ts │ │ │ │ ├── context-value.ts │ │ │ │ ├── local-resolvers-without-context-value.ts │ │ │ │ ├── local-resolvers.ts │ │ │ │ └── localSchema.graphql │ │ │ ├── forcedResolvers.test.ts │ │ │ ├── fragments.test.ts │ │ │ ├── partialData.test.ts │ │ │ ├── rootValue.test.ts │ │ │ ├── subscriptions.test.ts │ │ │ ├── testUtils.ts │ │ │ └── types.test.ts │ │ └── index.ts │ ├── masking/ │ │ ├── GraphQLCodegenDataMasking.ts │ │ ├── PreserveTypes.ts │ │ ├── __benches__/ │ │ │ └── types.bench.ts │ │ ├── __tests__/ │ │ │ ├── maskFragment.test.ts │ │ │ ├── maskOperation.test.ts │ │ │ └── utils.test.ts │ │ ├── index.ts │ │ ├── internal/ │ │ │ └── types.ts │ │ ├── maskDefinition.ts │ │ ├── maskFragment.ts │ │ ├── maskOperation.ts │ │ ├── types.ts │ │ └── utils.ts │ ├── react/ │ │ ├── context/ │ │ │ ├── ApolloContext.ts │ │ │ ├── ApolloProvider.tsx │ │ │ └── __tests__/ │ │ │ └── ApolloProvider.test.tsx │ │ ├── hooks/ │ │ │ ├── __tests__/ │ │ │ │ ├── bundle.test.tsx │ │ │ │ ├── useApolloClient.test.tsx │ │ │ │ ├── useBackgroundQuery/ │ │ │ │ │ ├── defer20220824.test.tsx │ │ │ │ │ ├── deferGraphQL17Alpha9.test.tsx │ │ │ │ │ ├── skipToken.test.tsx │ │ │ │ │ ├── streamDefer20220824.test.tsx │ │ │ │ │ ├── streamGraphQL17Alpha9.test.tsx │ │ │ │ │ └── testUtils.tsx │ │ │ │ ├── useBackgroundQuery.test.tsx │ │ │ │ ├── useFragment/ │ │ │ │ │ └── arrays.test.tsx │ │ │ │ ├── useFragment.test.tsx │ │ │ │ ├── useLazyQuery.test.tsx │ │ │ │ ├── useLoadableQuery/ │ │ │ │ │ ├── defer20220824.test.tsx │ │ │ │ │ └── deferGraphQL17Alpha9.test.tsx │ │ │ │ ├── useLoadableQuery.test.tsx │ │ │ │ ├── useMutation/ │ │ │ │ │ ├── context.test.tsx │ │ │ │ │ ├── defer20220824.test.tsx │ │ │ │ │ └── deferGraphQL17Alpha9.test.tsx │ │ │ │ ├── useMutation.test.tsx │ │ │ │ ├── useQuery/ │ │ │ │ │ ├── defer20220824.test.tsx │ │ │ │ │ ├── deferGraphQL17Alpha9.test.tsx │ │ │ │ │ ├── streamDefer20220824.test.tsx │ │ │ │ │ └── streamGraphQL17Alpha9.test.tsx │ │ │ │ ├── useQuery.test.tsx │ │ │ │ ├── useQueryRefHandlers.test.tsx │ │ │ │ ├── useReactiveVar.test.tsx │ │ │ │ ├── useSubscription.test.tsx │ │ │ │ ├── useSuspenseFragment/ │ │ │ │ │ └── arrays.test.tsx │ │ │ │ ├── useSuspenseFragment.test.tsx │ │ │ │ ├── useSuspenseQuery/ │ │ │ │ │ ├── defer20220824.test.tsx │ │ │ │ │ ├── deferGraphQL17Alpha9.test.tsx │ │ │ │ │ ├── skipToken.test.tsx │ │ │ │ │ ├── streamDefer20220824.test.tsx │ │ │ │ │ ├── streamGraphQL17Alpha9.test.tsx │ │ │ │ │ └── testUtils.tsx │ │ │ │ └── useSuspenseQuery.test.tsx │ │ │ ├── constants.ts │ │ │ ├── internal/ │ │ │ │ ├── __tests__/ │ │ │ │ │ ├── useDeepMemo.test.ts │ │ │ │ │ └── useRenderGuard.test.tsx │ │ │ │ ├── __use.ts │ │ │ │ ├── index.ts │ │ │ │ ├── useDeepMemo.ts │ │ │ │ ├── useIsomorphicLayoutEffect.ts │ │ │ │ ├── useRenderGuard.ts │ │ │ │ ├── useSuspenseHookCacheKey.ts │ │ │ │ ├── validateSuspenseHookOptions.ts │ │ │ │ └── wrapHook.ts │ │ │ ├── useApolloClient.ts │ │ │ ├── useBackgroundQuery.ts │ │ │ ├── useFragment.ts │ │ │ ├── useLazyQuery.ts │ │ │ ├── useLoadableQuery.ts │ │ │ ├── useMutation.ts │ │ │ ├── useQuery.ts │ │ │ ├── useQueryRefHandlers.ts │ │ │ ├── useReactiveVar.ts │ │ │ ├── useReadQuery.ts │ │ │ ├── useSubscription.ts │ │ │ ├── useSuspenseFragment.ts │ │ │ ├── useSuspenseQuery.ts │ │ │ └── useSyncExternalStore.ts │ │ ├── index.react-server.ts │ │ ├── index.ts │ │ ├── internal/ │ │ │ ├── cache/ │ │ │ │ ├── FragmentReference.ts │ │ │ │ ├── QueryReference.ts │ │ │ │ ├── SuspenseCache.ts │ │ │ │ ├── __tests__/ │ │ │ │ │ ├── QueryReference.test.tsx │ │ │ │ │ └── SuspenseCache.ts │ │ │ │ ├── getSuspenseCache.ts │ │ │ │ └── types.ts │ │ │ ├── compiler-runtime/ │ │ │ │ ├── LICENSE │ │ │ │ └── index.ts │ │ │ ├── index.ts │ │ │ └── types.ts │ │ ├── query-preloader/ │ │ │ ├── __tests__/ │ │ │ │ ├── createQueryPreloader/ │ │ │ │ │ ├── defer20220824.test.tsx │ │ │ │ │ └── deferGraphQL17Alpha9.test.tsx │ │ │ │ └── createQueryPreloader.test.tsx │ │ │ └── createQueryPreloader.ts │ │ ├── ssr/ │ │ │ ├── __tests__/ │ │ │ │ ├── __snapshots__/ │ │ │ │ │ ├── prerenderStatic.test.tsx.snap │ │ │ │ │ └── useQuery.test.tsx.snap │ │ │ │ ├── getDataFromTree.test.tsx │ │ │ │ ├── polyfillReactDomTypes.d.ts │ │ │ │ ├── prerenderStatic.test.tsx │ │ │ │ ├── useQuery.test.tsx │ │ │ │ ├── useQueryEndToEnd.test.tsx │ │ │ │ └── useReactiveVar.test.tsx │ │ │ ├── getDataFromTree.ts │ │ │ ├── index.ts │ │ │ ├── prerenderStatic.tsx │ │ │ ├── renderToStringWithData.ts │ │ │ └── useSSRQuery.ts │ │ └── types/ │ │ ├── deprecated.ts │ │ └── types.documentation.ts │ ├── testing/ │ │ ├── core/ │ │ │ ├── mocking/ │ │ │ │ ├── __tests__/ │ │ │ │ │ ├── __snapshots__/ │ │ │ │ │ │ └── mockLink.ts.snap │ │ │ │ │ └── mockLink.ts │ │ │ │ ├── mockLink.ts │ │ │ │ └── mockSubscriptionLink.ts │ │ │ └── types/ │ │ │ └── deprecated.ts │ │ ├── index.ts │ │ ├── internal/ │ │ │ ├── ObservableStream.ts │ │ │ ├── __tests__/ │ │ │ │ └── ObservableStream.test.ts │ │ │ ├── asyncIterableSubject.ts │ │ │ ├── declarations.d.ts │ │ │ ├── disposables/ │ │ │ │ ├── __tests__/ │ │ │ │ │ ├── spyOnConsole.test.ts │ │ │ │ │ └── withCleanup.test.ts │ │ │ │ ├── enableFakeTimers.ts │ │ │ │ ├── index.ts │ │ │ │ ├── spyOnConsole.ts │ │ │ │ ├── withCleanup.ts │ │ │ │ └── withProdMode.ts │ │ │ ├── incremental/ │ │ │ │ ├── executeSchemaGraphQL17Alpha2.ts │ │ │ │ └── executeSchemaGraphQL17Alpha9.ts │ │ │ ├── index.ts │ │ │ ├── link.ts │ │ │ ├── markAsStreaming.ts │ │ │ ├── messageChannelPolyfill.ts │ │ │ ├── multipart/ │ │ │ │ ├── mockDefer20220824.ts │ │ │ │ ├── mockDeferStreamGraphql17Alpha9.ts │ │ │ │ ├── mockMultipartSubscriptionStream.ts │ │ │ │ └── utils.ts │ │ │ ├── promiseWithResolvers.ts │ │ │ ├── renderHelpers.tsx │ │ │ ├── resetApolloContext.ts │ │ │ ├── rtl/ │ │ │ │ ├── actAsync.ts │ │ │ │ ├── renderAsync.ts │ │ │ │ └── renderHookAsync.tsx │ │ │ ├── scenarios/ │ │ │ │ └── index.ts │ │ │ ├── schemas/ │ │ │ │ ├── friendList.graphql17Alpha2.ts │ │ │ │ └── friendList.graphql17Alpha9.ts │ │ │ └── wait.ts │ │ ├── matchers/ │ │ │ ├── arrayWithLength.ts │ │ │ ├── index.d.ts │ │ │ ├── index.ts │ │ │ ├── isSameClient.ts │ │ │ ├── isSameObservableQuery.ts │ │ │ ├── toBeDisposed.ts │ │ │ ├── toBeGarbageCollected.ts │ │ │ ├── toComplete.ts │ │ │ ├── toEmitAnything.ts │ │ │ ├── toEmitError.ts │ │ │ ├── toEmitNext.ts │ │ │ ├── toEmitTypedValue.ts │ │ │ ├── toHaveFragmentWatchesOn.ts │ │ │ ├── toHaveNumWatches.ts │ │ │ ├── toHaveSuspenseCacheEntryUsing.ts │ │ │ ├── toMatchDocument.ts │ │ │ ├── toRerenderWithSimilarSnapshot.ts │ │ │ ├── toStrictEqualTyped.ts │ │ │ └── utils/ │ │ │ └── getSerializableProperties.ts │ │ └── react/ │ │ ├── MockedProvider.tsx │ │ ├── __tests__/ │ │ │ ├── MockedProvider.test.tsx │ │ │ ├── __snapshots__/ │ │ │ │ └── MockedProvider.test.tsx.snap │ │ │ └── mockSubscriptionLink.test.tsx │ │ └── index.ts │ ├── utilities/ │ │ ├── DeepPartial.ts │ │ ├── HKT.ts │ │ ├── caching/ │ │ │ ├── __tests__/ │ │ │ │ ├── getMemoryInternals.ts │ │ │ │ └── sizes.test.ts │ │ │ ├── index.ts │ │ │ └── sizes.ts │ │ ├── common/ │ │ │ ├── __tests__/ │ │ │ │ ├── canonicalStringify.ts │ │ │ │ └── stripTypename.ts │ │ │ └── stripTypename.ts │ │ ├── environment/ │ │ │ ├── index.development.ts │ │ │ ├── index.production.ts │ │ │ └── index.ts │ │ ├── graphql/ │ │ │ ├── DocumentTransform.ts │ │ │ ├── __tests__/ │ │ │ │ ├── DocumentTransform.ts │ │ │ │ └── transform.ts │ │ │ ├── isFormattedExecutionResult.ts │ │ │ ├── operations.ts │ │ │ ├── print.ts │ │ │ ├── storeUtils.ts │ │ │ └── transform.ts │ │ ├── index.ts │ │ ├── internal/ │ │ │ ├── DeepMerger.ts │ │ │ ├── __tests__/ │ │ │ │ ├── DeepMerger.test.ts │ │ │ │ ├── canUseDOM.test.ts │ │ │ │ ├── checkDocument.test.ts │ │ │ │ ├── cloneDeep.test.ts │ │ │ │ ├── compact.test.ts │ │ │ │ ├── createFragmentMap.test.ts │ │ │ │ ├── equalByQuery.ts │ │ │ │ ├── getDefaultValues.test.ts │ │ │ │ ├── getFragmentDefinitions.test.ts │ │ │ │ ├── getFragmentQueryDocument.test.ts │ │ │ │ ├── getOperationName.test.ts │ │ │ │ ├── getQueryDefinition.test.ts │ │ │ │ ├── getStoreKeyName.test.ts │ │ │ │ ├── hasDirectives.test.ts │ │ │ │ ├── maybeDeepFreeze.test.ts │ │ │ │ ├── mergeDeep.test.ts │ │ │ │ ├── mergeDeepArray.test.ts │ │ │ │ ├── omitDeep.test.ts │ │ │ │ ├── removeDirectivesFromDocument.test.ts │ │ │ │ └── shouldInclude.test.ts │ │ │ ├── argumentsObjectFromField.ts │ │ │ ├── bindCacheKey.ts │ │ │ ├── caches.ts │ │ │ ├── canUseDOM.ts │ │ │ ├── canonicalStringify.ts │ │ │ ├── checkDocument.ts │ │ │ ├── cloneDeep.ts │ │ │ ├── combineLatestBatched.ts │ │ │ ├── compact.ts │ │ │ ├── constants.ts │ │ │ ├── createFragmentMap.ts │ │ │ ├── createFulfilledPromise.ts │ │ │ ├── createRejectedPromise.ts │ │ │ ├── dealias.ts │ │ │ ├── decoratePromise.ts │ │ │ ├── deepFreeze.ts │ │ │ ├── equalByQuery.ts │ │ │ ├── filterMap.ts │ │ │ ├── getDefaultValues.ts │ │ │ ├── getFragmentDefinition.ts │ │ │ ├── getFragmentDefinitions.ts │ │ │ ├── getFragmentFromSelection.ts │ │ │ ├── getFragmentQueryDocument.ts │ │ │ ├── getGraphQLErrorsFromResult.ts │ │ │ ├── getMainDefinition.ts │ │ │ ├── getMemoryInternals.ts │ │ │ ├── getOperationDefinition.ts │ │ │ ├── getOperationName.ts │ │ │ ├── getQueryDefinition.ts │ │ │ ├── getStoreKeyName.ts │ │ │ ├── globals/ │ │ │ │ ├── global.ts │ │ │ │ ├── index.ts │ │ │ │ └── maybe.ts │ │ │ ├── graphQLResultHasError.ts │ │ │ ├── hasDirectives.ts │ │ │ ├── hasForcedResolvers.ts │ │ │ ├── index.production.ts │ │ │ ├── index.ts │ │ │ ├── isArray.ts │ │ │ ├── isDocumentNode.ts │ │ │ ├── isField.ts │ │ │ ├── isNonEmptyArray.ts │ │ │ ├── isNonNullObject.ts │ │ │ ├── isPlainObject.ts │ │ │ ├── makeReference.ts │ │ │ ├── makeUniqueId.ts │ │ │ ├── mapObservableFragment.ts │ │ │ ├── maybeDeepFreeze.ts │ │ │ ├── memoize.ts │ │ │ ├── mergeDeep.ts │ │ │ ├── mergeDeepArray.ts │ │ │ ├── mergeOptions.ts │ │ │ ├── omitDeep.ts │ │ │ ├── ponyfills/ │ │ │ │ ├── FinalizationRegistry.ts │ │ │ │ ├── __tests__/ │ │ │ │ │ └── FinalizationRegistry.test.ts │ │ │ │ ├── index.react-native.ts │ │ │ │ └── index.ts │ │ │ ├── preventUnhandledRejection.ts │ │ │ ├── removeDirectivesFromDocument.ts │ │ │ ├── removeFragmentSpreads.ts │ │ │ ├── resultKeyNameFromField.ts │ │ │ ├── shouldInclude.ts │ │ │ ├── storeKeyNameFromField.ts │ │ │ ├── stringifyForDisplay.ts │ │ │ ├── toQueryResult.ts │ │ │ ├── types/ │ │ │ │ ├── ApplyHKT.ts │ │ │ │ ├── ApplyHKTImplementationWithDefault.ts │ │ │ │ ├── DecoratedPromise.ts │ │ │ │ ├── DeepOmit.ts │ │ │ │ ├── DocumentationTypes.ts │ │ │ │ ├── ExtensionsWithStreamDetails.ts │ │ │ │ ├── FragmentMap.ts │ │ │ │ ├── FragmentMapFunction.ts │ │ │ │ ├── FulfilledPromise.ts │ │ │ │ ├── IsAny.ts │ │ │ │ ├── NoInfer.ts │ │ │ │ ├── PendingPromise.ts │ │ │ │ ├── Prettify.ts │ │ │ │ ├── Primitive.ts │ │ │ │ ├── RejectedPromise.ts │ │ │ │ ├── RemoveIndexSignature.ts │ │ │ │ ├── StreamInfoTrie.ts │ │ │ │ ├── TupleToIntersection.ts │ │ │ │ ├── VariablesOption.ts │ │ │ │ └── __tests__/ │ │ │ │ └── HTK.test.ts │ │ │ └── valueToObjectRepresentation.ts │ │ ├── invariant/ │ │ │ ├── __tests__/ │ │ │ │ └── invariant.test.ts │ │ │ ├── index.development.ts │ │ │ └── index.ts │ │ ├── isNetworkRequestInFlight.ts │ │ ├── isNetworkRequestSettled.ts │ │ ├── policies/ │ │ │ ├── __tests__/ │ │ │ │ └── relayStylePagination.test.ts │ │ │ └── pagination.ts │ │ └── subscriptions/ │ │ └── relay/ │ │ ├── __tests__/ │ │ │ └── createFetchMultipartSubscription.test.ts │ │ └── index.ts │ ├── v4-migration.ts │ └── version.ts ├── tests.codegen.ts ├── tsconfig.build.json ├── tsconfig.json ├── tsconfig.tests.json └── tsdoc.json
Showing preview only (260K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3557 symbols across 437 files)
FILE: .github/workflows/cleanup-checks.mjs
function setup (line 3) | function setup({ context, github }) {
FILE: codegen/local-state/config.ts
type LocalStatePluginConfig (line 39) | interface LocalStatePluginConfig extends RawConfig {
FILE: codegen/local-state/visitor.ts
type FieldDefinitionPrintFn (line 70) | type FieldDefinitionPrintFn = (
constant ENUM_RESOLVERS_SIGNATURE (line 75) | const ENUM_RESOLVERS_SIGNATURE =
type ParsedTypeScriptResolversConfig (line 78) | interface ParsedTypeScriptResolversConfig extends ParsedResolversConfig {
class LocalStateVisitor (line 86) | class LocalStateVisitor extends BaseResolversVisitor<
method constructor (line 90) | constructor(
method applyResolverTypeWrapper (line 127) | protected applyResolverTypeWrapper(str: string): string {
method createResolversFields (line 131) | protected createResolversFields({
method formatRootResolver (line 356) | protected formatRootResolver(
method clearOptional (line 368) | private clearOptional(str: string): string {
method ListType (line 376) | ListType(node: ListTypeNode): string {
method DirectiveDefinition (line 380) | DirectiveDefinition(
method EnumTypeDefinition (line 388) | EnumTypeDefinition(node: EnumTypeDefinitionNode): string {
method ObjectTypeDefinition (line 428) | ObjectTypeDefinition(node: ObjectTypeDefinitionNode): string {
method UnionTypeDefinition (line 475) | UnionTypeDefinition(
method FieldDefinition (line 483) | FieldDefinition(
method InterfaceTypeDefinition (line 587) | InterfaceTypeDefinition(_node: InterfaceTypeDefinitionNode): string {
method getRootResolver (line 591) | public getRootResolver(): RootResolver {
method wrapWithListType (line 637) | protected wrapWithListType(str: string): string {
method getParentTypeForSignature (line 641) | protected getParentTypeForSignature(_node: FieldDefinitionNode) {
method NamedType (line 645) | NamedType(node: NamedTypeNode): string {
method NonNullType (line 649) | NonNullType(node: NonNullTypeNode): string {
method ScalarTypeDefinition (line 655) | ScalarTypeDefinition(node: ScalarTypeDefinitionNode): string {
method getPunctuation (line 663) | protected getPunctuation(_declarationKind: DeclarationKind): string {
method buildEnumResolverContentBlock (line 667) | protected buildEnumResolverContentBlock(
method buildEnumResolversExplicitMappedValues (line 685) | protected buildEnumResolversExplicitMappedValues(
function replacePlaceholder (line 702) | function replacePlaceholder(pattern: string, typename: string): string {
function hasPlaceholder (line 706) | function hasPlaceholder(pattern: string): boolean {
FILE: config/FixJSDOMEnvironment.js
class FixJSDOMEnvironment (line 4) | class FixJSDOMEnvironment extends JSDOMEnvironment {
method constructor (line 5) | constructor(...args) {
FILE: config/apiExtractor.ts
function buildReport (line 153) | async function buildReport(
FILE: config/babel.ts
method transformStep (line 10) | async transformStep({ ast, sourceName, relativeSourcePath }) {
FILE: config/build.ts
type BuildStepOptions (line 19) | interface BuildStepOptions {
type BuildStep (line 30) | type BuildStep = {
type BuildSteps (line 33) | type BuildSteps = Record<string, BuildStep>;
FILE: config/compileTs.ts
function renameJsFilesToCjs (line 47) | function renameJsFilesToCjs(options: BuildStepOptions) {
function withBuildTsConfig (line 129) | async function withBuildTsConfig() {
function getEntryPoints (line 145) | function getEntryPoints() {
FILE: config/deprecateInternals.ts
method transformStep (line 10) | transformStep({ ast }) {
FILE: config/entryPoints.ts
type ExportsCondition (line 14) | type ExportsCondition = string | { [key: string]: ExportsCondition };
type EntryPoint (line 16) | type EntryPoint = {
FILE: config/exports.ts
type ConditionRoot (line 9) | type ConditionRoot = {
function processEntryPoint (line 68) | function processEntryPoint(value: string, existing: ConditionRoot = {}) {
function writeLegacyExport (line 97) | async function writeLegacyExport(
FILE: config/helpers.ts
function reparse (line 28) | function reparse(source: string) {
function reprint (line 32) | function reprint(ast: ReturnType<typeof reparse>) {
type MaybePromise (line 36) | type MaybePromise<T> = T | Promise<T>;
function applyRecast (line 38) | async function applyRecast({
function withPseudoNodeModules (line 137) | async function withPseudoNodeModules<T>(fn: () => T) {
function frameComment (line 153) | function frameComment(text: string) {
type PackageJson (line 163) | type PackageJson = Omit<JSONSchemaForNPMPackageJsonFiles, "author"> & {
function updatePackageJson (line 167) | async function updatePackageJson(
function patchApiExtractorInternals (line 183) | function patchApiExtractorInternals() {
FILE: config/inlineInheritDoc.ts
function getCommentFor (line 62) | function getCommentFor(
function loadApiModel (line 105) | function loadApiModel(options: BuildStepOptions) {
function processComments (line 177) | function processComments(model: ApiModel, options: BuildStepOptions) {
function renderDocComment (line 240) | function renderDocComment(node: DocComment): string {
FILE: config/listImports.ts
method resolve (line 14) | resolve(specifier, context, nextResolve) {
FILE: config/preserveTsIgnore.ts
method transformStep (line 27) | transformStep({ ast }) {
FILE: config/prettier/format-jsdoc.js
method print (line 28) | print(path, options, print, args) {
method embed (line 31) | embed(path, options) {
FILE: config/prettier/format-mdx3.js
function handleCodeBlockWithSpecialComments (line 44) | function handleCodeBlockWithSpecialComments(node, path, options) {
method embed (line 102) | embed(path, options) {
FILE: config/processInvariants.ts
type Node (line 11) | type Node = recast.types.namedTypes.Node;
type CallExpression (line 12) | type CallExpression = recast.types.namedTypes.CallExpression;
type NewExpression (line 13) | type NewExpression = recast.types.namedTypes.NewExpression;
function processInvariants (line 15) | async function processInvariants(options: BuildStepOptions) {
function addDevImport (line 356) | function addDevImport(ast: recast.types.ASTNode, type: "esm" | "cjs") {
FILE: config/react-compiler.ts
method transformStep (line 21) | async transformStep({ ast, sourceName, relativeSourcePath }) {
method transformStep (line 108) | transformStep({ ast, sourceName }) {
method transformStep (line 150) | transformStep({ ast, sourceName }) {
FILE: config/schema.package.json.ts
type JSONSchemaForNPMPackageJsonFiles (line 8) | type JSONSchemaForNPMPackageJsonFiles = {
type License (line 512) | type License =
type Person (line 541) | type Person = {
type Person1 (line 547) | type Person1 =
type PackageExportsEntry (line 555) | type PackageExportsEntry =
type PackageExportsEntryPath (line 561) | type PackageExportsEntryPath = string | null;
type PackageExportsFallback (line 565) | type PackageExportsFallback = PackageExportsEntry[];
type PackageExportsFallback1 (line 569) | type PackageExportsFallback1 = PackageExportsEntry[];
type PackageImportsEntry (line 570) | type PackageImportsEntry =
type PackageImportsEntryPath (line 576) | type PackageImportsEntryPath = string | null;
type PackageImportsFallback (line 580) | type PackageImportsFallback = PackageImportsEntry[];
type FundingUrl (line 584) | type FundingUrl = string;
type ScriptsPublishAfter (line 588) | type ScriptsPublishAfter = string;
type ScriptsInstallAfter (line 592) | type ScriptsInstallAfter = string;
type ScriptsUninstallBefore (line 596) | type ScriptsUninstallBefore = string;
type ScriptsVersionBefore (line 600) | type ScriptsVersionBefore = string;
type ScriptsTest (line 604) | type ScriptsTest = string;
type ScriptsStop (line 608) | type ScriptsStop = string;
type ScriptsStart (line 612) | type ScriptsStart = string;
type ScriptsRestart (line 616) | type ScriptsRestart = string;
type Plugins (line 620) | type Plugins = string[];
type Rules (line 624) | type Rules = PossibleErrors &
type Overrides (line 636) | type Overrides = {
type SchemaForPrettierrc (line 663) | type SchemaForPrettierrc =
type SimpleStringOrArrayStringRule (line 669) | type SimpleStringOrArrayStringRule = (string | SimpleArrayStringRule) &
type SimpleArrayStringRule (line 674) | type SimpleArrayStringRule = string[];
type SimpleArrayStringRule1 (line 678) | type SimpleArrayStringRule1 = string[];
type AllRules (line 679) | type AllRules = AtRule &
type ArrayStringRule (line 712) | type ArrayStringRule = (
type LowerUpperRule (line 836) | type LowerUpperRule = (
type AlwaysMultiLineRule (line 948) | type AlwaysMultiLineRule = (
type BooleanRule (line 1064) | type BooleanRule = (
type ArrayStringRule1 (line 1128) | type ArrayStringRule1 = (
type NewlineSpaceWithIgnoreRule (line 1252) | type NewlineSpaceWithIgnoreRule = (
type NewlineRule (line 1892) | type NewlineRule = (
type NewlineSpaceRule (line 2198) | type NewlineSpaceRule = (
type NewlineSpaceRule1 (line 2886) | type NewlineSpaceRule1 = (
type BooleanRule1 (line 3574) | type BooleanRule1 = (
type BooleanRule2 (line 3638) | type BooleanRule2 = (
type NewlineRule1 (line 3702) | type NewlineRule1 = (
type NewlineSpaceRule2 (line 4008) | type NewlineSpaceRule2 = (
type NewlineSpaceWithIgnoreRule1 (line 4696) | type NewlineSpaceWithIgnoreRule1 = (
type LowerUpperRule1 (line 5336) | type LowerUpperRule1 = (
type BooleanRule3 (line 5448) | type BooleanRule3 = (
type BooleanRule4 (line 5512) | type BooleanRule4 = (
type BooleanRule5 (line 5576) | type BooleanRule5 = (
type AlwaysNeverRule (line 5640) | type AlwaysNeverRule = (
type ArrayStringRule2 (line 5752) | type ArrayStringRule2 = (
type StringRule (line 5876) | type StringRule = (
type BooleanRule6 (line 5936) | type BooleanRule6 = (
type StringRule1 (line 6000) | type StringRule1 = (
type AlwaysNeverRule1 (line 6060) | type AlwaysNeverRule1 = (
type AlwaysNeverRule2 (line 6172) | type AlwaysNeverRule2 = (
type AlwaysMultiLineRule1 (line 6284) | type AlwaysMultiLineRule1 = (
type AlwaysNeverRule3 (line 6400) | type AlwaysNeverRule3 = (
type BooleanRule7 (line 6512) | type BooleanRule7 = (
type SimpleStringOrArrayStringRule1 (line 6573) | type SimpleStringOrArrayStringRule1 = (string | SimpleArrayStringRule) &
type BooleanRule8 (line 6581) | type BooleanRule8 = (
type BooleanRule9 (line 6645) | type BooleanRule9 = (
type NewlineRule2 (line 6709) | type NewlineRule2 = (
type NewlineRule3 (line 7015) | type NewlineRule3 = (
type SpaceRule (line 7321) | type SpaceRule = (
type SpaceRule1 (line 7875) | type SpaceRule1 = (
type IntegerRule (line 8429) | type IntegerRule = (
type AlwaysNeverRule4 (line 8489) | type AlwaysNeverRule4 = (
type ArrayStringRule3 (line 8601) | type ArrayStringRule3 = (
type BooleanRule10 (line 8725) | type BooleanRule10 = (
type NewlineRule4 (line 8789) | type NewlineRule4 = (
type NewlineRule5 (line 9095) | type NewlineRule5 = (
type SpaceRule2 (line 9401) | type SpaceRule2 = (
type SpaceRule3 (line 9955) | type SpaceRule3 = (
type BooleanRule11 (line 10509) | type BooleanRule11 = (
type IntegerRule1 (line 10573) | type IntegerRule1 = (
type NewlineRule6 (line 10633) | type NewlineRule6 = (
type SpaceRule4 (line 10939) | type SpaceRule4 = (
type AlwaysNeverRule5 (line 11493) | type AlwaysNeverRule5 = (
type BooleanRule12 (line 11605) | type BooleanRule12 = (
type AlwaysNeverRule6 (line 11669) | type AlwaysNeverRule6 = (
type ArrayStringRule4 (line 11781) | type ArrayStringRule4 = (
type ArrayStringRule5 (line 11905) | type ArrayStringRule5 = (
type AlwaysNeverRule7 (line 12029) | type AlwaysNeverRule7 = (
type IntegerRule2 (line 12141) | type IntegerRule2 = (
type BooleanRule13 (line 12201) | type BooleanRule13 = (
type BooleanRule14 (line 12265) | type BooleanRule14 = (
type BooleanRule15 (line 12329) | type BooleanRule15 = (
type BooleanRule16 (line 12393) | type BooleanRule16 = (
type BooleanRule17 (line 12457) | type BooleanRule17 = (
type BooleanRule18 (line 12521) | type BooleanRule18 = (
type BooleanRule19 (line 12585) | type BooleanRule19 = (
type AlwaysNeverRule8 (line 12649) | type AlwaysNeverRule8 = (
type BooleanRule20 (line 12761) | type BooleanRule20 = (
type BooleanRule21 (line 12825) | type BooleanRule21 = (
type AlwaysNeverRule9 (line 12889) | type AlwaysNeverRule9 = (
type AlwaysNeverRule10 (line 13001) | type AlwaysNeverRule10 = (
type LowerUpperRule2 (line 13113) | type LowerUpperRule2 = (
type BooleanRule22 (line 13225) | type BooleanRule22 = (
type BooleanRule23 (line 13289) | type BooleanRule23 = (
type AlwaysNeverRule11 (line 13353) | type AlwaysNeverRule11 = (
type AlwaysNeverRule12 (line 13465) | type AlwaysNeverRule12 = (
type AlwaysNeverRule13 (line 13577) | type AlwaysNeverRule13 = (
type NewlineRule7 (line 13689) | type NewlineRule7 = (
type NewlineRule8 (line 13995) | type NewlineRule8 = (
type SpaceRule5 (line 14301) | type SpaceRule5 = (
type SpaceRule6 (line 14855) | type SpaceRule6 = (
type AlwaysNeverRule14 (line 15409) | type AlwaysNeverRule14 = (
type IntegerRule3 (line 15521) | type IntegerRule3 = (
type BooleanRule24 (line 15581) | type BooleanRule24 = (
type ArrayStringRule6 (line 15645) | type ArrayStringRule6 = (
type LowerUpperRule3 (line 15769) | type LowerUpperRule3 = (
type BooleanRule25 (line 15881) | type BooleanRule25 = (
type ArrayStringRule7 (line 15945) | type ArrayStringRule7 = (
type BooleanRule26 (line 16069) | type BooleanRule26 = (
type AlwaysNeverRule15 (line 16133) | type AlwaysNeverRule15 = (
type ArrayStringRule8 (line 16245) | type ArrayStringRule8 = (
type AlwaysNeverRule16 (line 16369) | type AlwaysNeverRule16 = (
type AlwaysNeverRule17 (line 16481) | type AlwaysNeverRule17 = (
type ArrayStringRule9 (line 16593) | type ArrayStringRule9 = (
type AlwaysNeverRule18 (line 16717) | type AlwaysNeverRule18 = (
type AlwaysNeverRule19 (line 16829) | type AlwaysNeverRule19 = (
type AlwaysNeverRule20 (line 16941) | type AlwaysNeverRule20 = (
type BooleanRule27 (line 17053) | type BooleanRule27 = (
type StringRule2 (line 17117) | type StringRule2 = (
type IntegerRule4 (line 17177) | type IntegerRule4 = (
type StringRule3 (line 17237) | type StringRule3 = (
type StringRule4 (line 17297) | type StringRule4 = (
type BooleanRule28 (line 17357) | type BooleanRule28 = (
type BooleanRule29 (line 17421) | type BooleanRule29 = (
type BooleanRule30 (line 17485) | type BooleanRule30 = (
type BooleanRule31 (line 17549) | type BooleanRule31 = (
type BooleanRule32 (line 17613) | type BooleanRule32 = (
type LowerUpperRule4 (line 17677) | type LowerUpperRule4 = (
type AlwaysNeverRule21 (line 17789) | type AlwaysNeverRule21 = (
type ArrayStringRule10 (line 17901) | type ArrayStringRule10 = (
type LowerUpperRule5 (line 18025) | type LowerUpperRule5 = (
type SingleDoubleRule (line 18137) | type SingleDoubleRule = (
type BooleanRule33 (line 18249) | type BooleanRule33 = (
type LowerUpperRule6 (line 18313) | type LowerUpperRule6 = (
type IntegerRule5 (line 18425) | type IntegerRule5 = (
type NewlineRule9 (line 18485) | type NewlineRule9 = (
type NewlineRule10 (line 18791) | type NewlineRule10 = (
type SpaceRule7 (line 19097) | type SpaceRule7 = (
type SpaceRule8 (line 19651) | type SpaceRule8 = (
type BooleanRule34 (line 20205) | type BooleanRule34 = (
type BooleanRule35 (line 20269) | type BooleanRule35 = (
type SingleDoubleRule1 (line 20333) | type SingleDoubleRule1 = (
type BooleanRule36 (line 20445) | type BooleanRule36 = (
type UnitRule (line 20509) | type UnitRule = (
type LowerUpperRule7 (line 27129) | type LowerUpperRule7 = (
type UnitRule1 (line 27241) | type UnitRule1 = (
type BooleanRule37 (line 33861) | type BooleanRule37 = (
type NewlineRule11 (line 33925) | type NewlineRule11 = (
type NewlineRule12 (line 34231) | type NewlineRule12 = (
type SpaceRule9 (line 34537) | type SpaceRule9 = (
type SpaceRule10 (line 35091) | type SpaceRule10 = (
type IntegerRule6 (line 35645) | type IntegerRule6 = (
type SimpleStringOrArrayStringRule2 (line 35705) | type SimpleStringOrArrayStringRule2 = (string | SimpleArrayStringRule) &
type BooleanRule38 (line 35713) | type BooleanRule38 = (
type BooleanRule39 (line 35777) | type BooleanRule39 = (
type BooleanRule40 (line 35841) | type BooleanRule40 = (
type ArrayOfPaths (line 35905) | type ArrayOfPaths = string[];
type ArrayOfPaths1 (line 35909) | type ArrayOfPaths1 = string[];
type ArrayOfPaths2 (line 35913) | type ArrayOfPaths2 = string[];
type ArrayOfStrings (line 35914) | type ArrayOfStrings = string[];
type ArrayOfPaths3 (line 35918) | type ArrayOfPaths3 = string[];
type ArrayOfStrings1 (line 35922) | type ArrayOfStrings1 = string[];
type ArrayOfPaths4 (line 35926) | type ArrayOfPaths4 = string[];
type PackageExportsEntryObject (line 35931) | interface PackageExportsEntryObject {
type PackageExportsEntryObject1 (line 35966) | interface PackageExportsEntryObject1 {
type PackageImportsEntryObject (line 36001) | interface PackageImportsEntryObject {
type FundingWay (line 36033) | interface FundingWay {
type Dependency (line 36043) | interface Dependency {
type PeerDependencyMeta (line 36049) | interface PeerDependencyMeta {
type JSONSchemaForESLintConfigurationFiles (line 36058) | interface JSONSchemaForESLintConfigurationFiles {
type EcmaFeatures (line 36093) | interface EcmaFeatures {
type Env (line 36136) | interface Env {
type Globals (line 36242) | interface Globals {
type ParserOptions (line 36248) | interface ParserOptions {
type PossibleErrors (line 36283) | interface PossibleErrors {
type BestPractices (line 36433) | interface BestPractices {
type StrictMode (line 36723) | interface StrictMode {
type Variables (line 36730) | interface Variables {
type NodeAndCommonJs (line 36784) | interface NodeAndCommonJs {
type StylisticIssues (line 36831) | interface StylisticIssues {
type EcmaScript6 (line 37237) | interface EcmaScript6 {
type Legacy (line 37368) | interface Legacy {
type HttpsJsonSchemastoreOrgPartialEslintPluginsJson (line 37377) | interface HttpsJsonSchemastoreOrgPartialEslintPluginsJson {
FILE: config/size-limit/index.js
method before (line 25) | async before(/** @type {Config} */ config) {
method step21 (line 35) | async step21(
FILE: config/verifySourceMaps.ts
method exclude (line 15) | exclude(fileName) {
function isEmptyFile (line 65) | function isEmptyFile(file: string) {
FILE: config/version.ts
method transformStep (line 25) | transformStep({ ast }) {
FILE: docs/shared/MdxProvidedComponents.ts
type HTMLAttributes (line 5) | interface HTMLAttributes<T> {
type AllComponents (line 151) | type AllComponents = {
type MDXProvidedComponents (line 177) | type MDXProvidedComponents = AllComponents;
FILE: eslint-local-rules/canonical-references.ts
method create (line 10) | create(context) {
method create (line 71) | create(context, optionsWithDefault) {
function locForMatch (line 105) | function locForMatch(
FILE: eslint-local-rules/forbid-act-in-disabled-act-environment.ts
method create (line 4) | create(context) {
FILE: eslint-local-rules/generics.ts
method create (line 5) | create(context) {
method create (line 50) | create(context) {
FILE: eslint-local-rules/import-from-export.ts
function findNearestEntryPointFolder (line 33) | function findNearestEntryPointFolder(filename: string) {
method create (line 44) | create(context) {
method create (line 84) | create(context) {
method create (line 125) | create(context) {
function getPublicExports (line 179) | function getPublicExports(path: string) {
method create (line 197) | create(context, options) {
method create (line 274) | create(context, options) {
FILE: eslint-local-rules/require-disable-act-environment.ts
type Fn (line 4) | type Fn =
method create (line 10) | create(context) {
function findParentFunction (line 72) | function findParentFunction(node: AST.Node): Fn | undefined {
FILE: eslint-local-rules/require-using-disposable.ts
method create (line 6) | create(context) {
function parts (line 57) | function parts(type: ts.Type): ts.Type[] {
FILE: eslint-local-rules/testSetup.ts
function mkRuleTester (line 11) | function mkRuleTester(
FILE: integration-tests/cra5/src/App.tsx
constant QUERY (line 33) | const QUERY: TypedDocumentNode<{
function App (line 47) | function App() {
function Main (line 55) | function Main() {
FILE: integration-tests/next/src/app/cc/ApolloWrapper.tsx
function ApolloWrapper (line 21) | function ApolloWrapper({ children }: React.PropsWithChildren<{}>) {
FILE: integration-tests/next/src/app/cc/layout.tsx
function Layout (line 3) | async function Layout({
FILE: integration-tests/next/src/app/cc/page.tsx
constant QUERY (line 7) | const QUERY: TypedDocumentNode<{
function Page (line 21) | function Page() {
FILE: integration-tests/next/src/app/layout.tsx
function RootLayout (line 6) | function RootLayout({
FILE: integration-tests/next/src/app/page.tsx
constant QUERY (line 5) | const QUERY: TypedDocumentNode<{
function Home (line 19) | async function Home() {
FILE: integration-tests/next/src/libs/apolloClient.ts
constant APOLLO_STATE_PROP_NAME (line 18) | const APOLLO_STATE_PROP_NAME = "__APOLLO_STATE__";
function createApolloClient (line 48) | function createApolloClient() {
function initializeApollo (line 62) | function initializeApollo(
type ApolloProps (line 93) | interface ApolloProps {
function addApolloState (line 97) | function addApolloState(
function useApollo (line 110) | function useApollo(pageProps?: ApolloProps) {
FILE: integration-tests/next/src/pages/_app.tsx
function App (line 5) | function App({ Component, pageProps }: AppProps) {
FILE: integration-tests/next/src/pages/pages-no-ssr.tsx
constant QUERY (line 7) | const QUERY: TypedDocumentNode<{
function Page (line 21) | function Page() {
FILE: integration-tests/next/src/pages/pages.tsx
constant QUERY (line 9) | const QUERY: TypedDocumentNode<{
function Page (line 23) | function Page() {
FILE: integration-tests/vite-swc/src/App.tsx
constant QUERY (line 33) | const QUERY: TypedDocumentNode<{
function App (line 47) | function App() {
function Main (line 55) | function Main() {
FILE: integration-tests/vite/src/ApolloLinkResultType.ts
type TData (line 9) | type TData = { foo: string };
type TExtensions (line 10) | type TExtensions = { bar: number };
FILE: integration-tests/vite/src/App.tsx
constant QUERY (line 33) | const QUERY: TypedDocumentNode<{
function App (line 47) | function App() {
function Main (line 55) | function Main() {
FILE: integration-tests/vite/src/enhanceDataStates.ts
type ExtendedTypedDocumentNode (line 10) | type ExtendedTypedDocumentNode<TCompleteData, TVariables, TStreaming> =
type Complete (line 20) | interface Complete extends HKT {
type Streaming (line 25) | interface Streaming extends HKT {
type Partial (line 30) | interface Partial extends HKT {
type TypeOverrides (line 37) | interface TypeOverrides {
type CompleteData (line 44) | type CompleteData = {
type StreamingData (line 51) | type StreamingData = {
type TData (line 94) | type TData =
FILE: integration-tests/vite/src/enhanceMaskingTypes.ts
type CustomMaybeMaskedImplementation (line 3) | type CustomMaybeMaskedImplementation<TData> = {
type CustomMaybeMaskedType (line 7) | interface CustomMaybeMaskedType extends HKT {
type CustomDataMaskingImplementation (line 12) | interface CustomDataMaskingImplementation {
type TypeOverrides (line 17) | interface TypeOverrides extends CustomDataMaskingImplementation {}
type TestMasked (line 22) | type TestMasked = MaybeMasked<{
FILE: integration-tests/wrapping-library/src/index.ts
function useWrappedQuery (line 15) | function useWrappedQuery<TData, TVariables extends OperationVariables>(
FILE: scripts/codemods/ac2-to-ac3/imports.js
function transformer (line 10) | function transformer(file, api) {
FILE: scripts/codemods/ac3-to-ac4/src/__tests__/handleIdentifierRename.test.ts
method onModify (line 43) | onModify() {
FILE: scripts/codemods/ac3-to-ac4/src/apolloClientInitialization.ts
type Steps (line 24) | type Steps = keyof typeof steps | "removeTypeArguments";
function onModified (line 38) | function onModified() {
type StepOptions (line 96) | interface StepOptions {
function explicitLinkConstruction (line 104) | function explicitLinkConstruction({
function clientAwareness (line 153) | function clientAwareness({
function localState (line 182) | function localState({
function devtoolsOption (line 244) | function devtoolsOption({
function prioritizeCacheValues (line 275) | function prioritizeCacheValues({
type ConstructorCall (line 294) | interface ConstructorCall {
function dataMasking (line 300) | function dataMasking({
function incrementalHandler (line 352) | function incrementalHandler({
function insertTypeOverrideBlock (line 412) | function insertTypeOverrideBlock({
constant CODEMOD_MARKER (line 512) | const CODEMOD_MARKER = `@apollo/client-codemod-migrate-3-to-4`;
FILE: scripts/codemods/ac3-to-ac4/src/devLoader.js
method resolve (line 4) | resolve(specifier, context, nextResolve) {
FILE: scripts/codemods/ac3-to-ac4/src/imports.ts
type ImportSpecifier (line 11) | interface ImportSpecifier {
method onModify (line 30) | onModify() {
method onModify (line 38) | onModify() {
FILE: scripts/codemods/ac3-to-ac4/src/index.ts
function transform (line 18) | async function transform(
FILE: scripts/codemods/ac3-to-ac4/src/legacyEntrypoints.ts
method onModify (line 17) | onModify() {
FILE: scripts/codemods/ac3-to-ac4/src/renames.ts
type IdentifierRename (line 756) | interface IdentifierRename {
type IdentifierRenameCommon (line 790) | interface IdentifierRenameCommon extends Omit<IdentifierRename, "from"> {
type ModuleRename (line 796) | interface ModuleRename {
function reorderGenerics (line 809) | function reorderGenerics(
function moveInto (line 828) | function moveInto(common: IdentifierRenameCommon) {
FILE: scripts/codemods/ac3-to-ac4/src/types.ts
type ImportKind (line 3) | type ImportKind = "type" | "value";
type UtilContext (line 5) | interface UtilContext {
FILE: scripts/codemods/ac3-to-ac4/src/util/callExpressionToNewExpression.ts
function callExpressionToNewExpression (line 9) | function callExpressionToNewExpression(): (args: {
FILE: scripts/codemods/ac3-to-ac4/src/util/findImportDeclarationFor.ts
function findImportDeclarationFor (line 17) | function findImportDeclarationFor({
FILE: scripts/codemods/ac3-to-ac4/src/util/findImportSpecifiersFor.ts
function findImportSpecifiersFor (line 9) | function findImportSpecifiersFor({
FILE: scripts/codemods/ac3-to-ac4/src/util/findOrInsertImport.ts
function findOrInsertImport (line 9) | function findOrInsertImport({
FILE: scripts/codemods/ac3-to-ac4/src/util/findReferences.ts
function findReferences (line 7) | function findReferences({
FILE: scripts/codemods/ac3-to-ac4/src/util/getAllExports.ts
type ExportInfo (line 11) | interface ExportInfo {
function analyze (line 18) | function analyze(
FILE: scripts/codemods/ac3-to-ac4/src/util/getProperty.ts
function getProperty (line 6) | function getProperty({
FILE: scripts/codemods/ac3-to-ac4/src/util/getUnusedIdentifier.ts
function getUnusedIdentifier (line 3) | function getUnusedIdentifier({
FILE: scripts/codemods/ac3-to-ac4/src/util/handleIdentiferRename.ts
function handleIdentiferRename (line 16) | function handleIdentiferRename({
function getLocalName (line 181) | function getLocalName(spec: j.ImportSpecifier): string {
FILE: scripts/codemods/ac3-to-ac4/src/util/handleModuleRename.ts
function handleModuleRename (line 6) | function handleModuleRename({
FILE: scripts/codemods/ac3-to-ac4/src/util/monkeyPatchAstTypes.ts
function monkeyPatchAstTypes (line 6) | function monkeyPatchAstTypes(j: JSCodeshift) {
FILE: scripts/codemods/ac3-to-ac4/src/util/moveGlobalIdentifierToNamespaceAccess.ts
function moveGlobalIdentifierToNamespaceAccess (line 8) | function moveGlobalIdentifierToNamespaceAccess({
FILE: scripts/codemods/ac3-to-ac4/src/util/pick.ts
function pick (line 1) | function pick<T extends Record<string, any>, K extends keyof T>(
FILE: scripts/codemods/ac3-to-ac4/src/util/renameGlobalIdentifier.ts
function renameGlobalIdentifier (line 3) | function renameGlobalIdentifier({
FILE: scripts/codemods/ac3-to-ac4/src/util/reorderGenericArguments.ts
function reorderGenericArguments (line 7) | function reorderGenericArguments({
FILE: scripts/codemods/data-masking/examples/queries-react.tsx
function MyComponent (line 22) | function MyComponent() {
FILE: scripts/codemods/data-masking/examples/queries.ts
constant SKIP_TO_NEXT_MUTATION (line 33) | const SKIP_TO_NEXT_MUTATION = gql`
constant SKIP_TO_NEXT_MUTATION_WITH_FRAGMENT (line 73) | const SKIP_TO_NEXT_MUTATION_WITH_FRAGMENT = gql`
FILE: scripts/codemods/data-masking/unmask.ts
constant LEADING_WHITESPACE (line 6) | const LEADING_WHITESPACE = /^[\s\t]*(?=[\S\n])/;
constant TRAILING_WHITESPACE (line 7) | const TRAILING_WHITESPACE = /(?<=[\S\n])[\s\t]*$/;
constant DEFAULT_TAGS (line 9) | const DEFAULT_TAGS = ["gql", "graphql"];
function addUnmaskToFunctionCall (line 38) | function addUnmaskToFunctionCall(name: string) {
function addUnmaskToTaggedTemplate (line 49) | function addUnmaskToTaggedTemplate(name: string) {
function addUnmaskToTemplateLiteral (line 59) | function addUnmaskToTemplateLiteral(template: Collection<TemplateLiteral...
function parseDocument (line 92) | function parseDocument(source: string) {
function applyIndentationFromOriginalQuery (line 100) | function applyIndentationFromOriginalQuery(
function addUnmaskDirective (line 125) | function addUnmaskDirective(document: DocumentNode, mode: string | undef...
function getMatch (line 158) | function getMatch(str: string, match: RegExp) {
function transformGraphQLFile (line 162) | function transformGraphQLFile(source: string, mode: string) {
FILE: scripts/codemods/misc/mockLinkRejection.ts
method visitCallExpression (line 14) | visitCallExpression(path) {
FILE: src/__tests__/ApolloClient.ts
type Friend (line 1106) | interface Friend {
type Data (line 1111) | interface Data {
function newClient (line 1138) | function newClient() {
method dataIdFromObject (line 1465) | dataIdFromObject(object) {
type Data (line 2902) | interface Data {
method refetchQueries (line 3111) | refetchQueries(result) {
method update (line 3116) | update(_, result) {
type Mutation (line 3127) | interface Mutation {
type Variables (line 3135) | interface Variables {
method refetchQueries (line 3183) | refetchQueries(result) {
method update (line 3200) | update(_, result) {
type UserFieldsFragment (line 3213) | type UserFieldsFragment = {
type Mutation (line 3218) | type Mutation = {
type UnmaskedMutation (line 3225) | type UnmaskedMutation = {
type Variables (line 3233) | interface Variables {
method refetchQueries (line 3270) | refetchQueries(result) {
method update (line 3287) | update(_, result) {
type UserFieldsFragment (line 3298) | type UserFieldsFragment = {
type Query (line 3302) | type Query = {
type Variables (line 3309) | interface Variables {
type UserFieldsFragment (line 3336) | type UserFieldsFragment = {
type Query (line 3341) | type Query = {
type UnmaskedQuery (line 3348) | type UnmaskedQuery = {
type Subscription (line 3356) | type Subscription = {
type UnmaskedSubscription (line 3363) | type UnmaskedSubscription = {
type Variables (line 3371) | interface Variables {
method updateQuery (line 3489) | updateQuery(queryData, { subscriptionData, complete, previousData }) {
type NonMaskingData (line 3521) | type NonMaskingData = {
FILE: src/__tests__/client.ts
method next (line 846) | next() {
method next (line 890) | next() {
method error (line 893) | error() {
function makeLink (line 2174) | function makeLink() {
method a (line 3500) | a() {
method b (line 3503) | b() {
function watch (line 3514) | function watch(
method c (line 3680) | c(value) {
function wait (line 3712) | function wait(time = 10) {
method a (line 3725) | a() {
method b (line 3728) | b() {
function watch (line 3740) | function watch(
method nextFetchPolicy (line 3908) | nextFetchPolicy(fetchPolicy, context) {
method nextFetchPolicy (line 4037) | nextFetchPolicy() {
method nextFetchPolicy (line 4055) | nextFetchPolicy(currentFetchPolicy) {
method Field (line 4291) | Field(node) {
method Field (line 4380) | Field(node) {
method Field (line 4466) | Field(node) {
method read (line 4513) | read() {
method Field (line 4794) | Field(node) {
method Field (line 5029) | Field(node) {
method Field (line 5326) | Field(node) {
method merge (line 5777) | merge(existing = [], incoming) {
method Field (line 6386) | Field(node) {
function clientRoundtrip (line 7098) | async function clientRoundtrip(
FILE: src/__tests__/dataMasking.ts
constant NO_CACHE_WARNING (line 26) | const NO_CACHE_WARNING =
type UserFieldsFragment (line 31) | type UserFieldsFragment = {
type Query (line 35) | interface Query {
type UserFieldsFragment (line 105) | type UserFieldsFragment = {
type Query (line 109) | interface Query {
type UserFieldsFragment (line 180) | type UserFieldsFragment = {
type Query (line 184) | interface Query {
type UserFieldsFragment (line 254) | type UserFieldsFragment = {
type Query (line 258) | interface Query {
method FragmentSpread (line 332) | FragmentSpread(node) {
type UserFieldsFragment (line 346) | type UserFieldsFragment = {
type Query (line 350) | interface Query {
type UserFieldsFragment (line 423) | type UserFieldsFragment = {
type Query (line 427) | interface Query {
type UserFieldsFragment (line 521) | type UserFieldsFragment = {
type Query (line 525) | interface Query {
type UserFieldsFragment (line 622) | type UserFieldsFragment = {
type Query (line 626) | interface Query {
type UserFieldsFragment (line 699) | type UserFieldsFragment = {
type Query (line 703) | interface Query {
type UserFieldsFragment (line 793) | type UserFieldsFragment = {
type Query (line 798) | interface Query {
type UserFieldsFragment (line 892) | type UserFieldsFragment = {
type Query (line 896) | interface Query {
type UserFieldsFragment (line 987) | type UserFieldsFragment = {
type Query (line 991) | interface Query {
type UserFieldsFragment (line 1076) | type UserFieldsFragment = {
type Query (line 1080) | interface Query {
type UserFieldsFragment (line 1169) | type UserFieldsFragment = {
type Query (line 1173) | interface Query {
type UserFieldsFragment (line 1243) | type UserFieldsFragment = {
type Query (line 1247) | interface Query {
type UserFieldsFragment (line 1330) | type UserFieldsFragment = {
type Query (line 1335) | interface Query {
type UserFieldsFragment (line 1424) | type UserFieldsFragment = {
type Query (line 1428) | interface Query {
type UserFieldsFragment (line 1515) | type UserFieldsFragment = {
type Query (line 1519) | interface Query {
type UserFieldsFragment (line 1578) | type UserFieldsFragment = {
type Query (line 1582) | interface Query {
type UserFieldsFragment (line 1698) | type UserFieldsFragment = {
type Query (line 1702) | interface Query {
type Variables (line 1710) | interface Variables {
type UserFieldsFragment (line 1822) | type UserFieldsFragment = {
type Query (line 1826) | interface Query {
type Variables (line 1834) | interface Variables {
type UserFieldsFragment (line 1946) | type UserFieldsFragment = {
type Query (line 1950) | interface Query {
type Variables (line 1958) | interface Variables {
type GreetingFragment (line 2055) | type GreetingFragment = {
type Query (line 2061) | interface Query {
type GreetingFragment (line 2164) | type GreetingFragment = {
type Query (line 2170) | interface Query {
type GreetingFragment (line 2275) | type GreetingFragment = {
type Query (line 2281) | interface Query {
type GreetingFragment (line 2385) | type GreetingFragment = {
type TimeFieldsFragment (line 2391) | type TimeFieldsFragment = {
type Query (line 2395) | interface Query {
type UserFieldsFragment (line 2510) | type UserFieldsFragment = {
type Query (line 2514) | interface Query {
type UserFieldsFragment (line 2589) | type UserFieldsFragment = {
type Query (line 2593) | interface Query {
type Query (line 2670) | interface Query {
type UserFieldsFragment (line 2746) | type UserFieldsFragment = {
type Query (line 2750) | interface Query {
type UserFieldsFragment (line 2834) | type UserFieldsFragment = {
type NameFieldsFragment (line 2842) | type NameFieldsFragment = {
type UserFieldsFragment (line 2913) | type UserFieldsFragment = {
type NameFieldsFragment (line 2921) | type NameFieldsFragment = {
type UserFieldsFragment (line 2999) | type UserFieldsFragment = {
type NameFieldsFragment (line 3007) | type NameFieldsFragment = {
type ProfileFieldsFragment (line 3085) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3090) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3147) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3152) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3225) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3230) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3311) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3316) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3425) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3431) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3537) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3543) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3655) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3661) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 3788) | type ProfileFieldsFragment = {
type UserFieldsFragment (line 3794) | type UserFieldsFragment = {
type UserFieldsFragment (line 3956) | type UserFieldsFragment = {
type NameFieldsFragment (line 3964) | type NameFieldsFragment = {
type UserFieldsFragment (line 4042) | type UserFieldsFragment = {
type NameFieldsFragment (line 4050) | type NameFieldsFragment = {
type UserFieldsFragment (line 4131) | type UserFieldsFragment = {
type Query (line 4135) | interface Query {
type UserFieldsFragment (line 4191) | type UserFieldsFragment = {
type Query (line 4195) | interface Query {
type UserFieldsFragment (line 4252) | type UserFieldsFragment = {
type Query (line 4256) | interface Query {
type UserFieldsFragment (line 4452) | type UserFieldsFragment = {
type Query (line 4456) | interface Query {
type UserFieldsFragment (line 4516) | type UserFieldsFragment = {
type Query (line 4520) | interface Query {
type UserFieldsFragment (line 4580) | type UserFieldsFragment = {
type Query (line 4584) | interface Query {
type UserFieldsFragment (line 4644) | type UserFieldsFragment = {
type Query (line 4648) | interface Query {
type UserFieldsFragment (line 5727) | type UserFieldsFragment = {
type Mutation (line 5731) | interface Mutation {
type UserFieldsFragment (line 5789) | type UserFieldsFragment = {
type Mutation (line 5793) | interface Mutation {
type UserFieldsFragment (line 5852) | type UserFieldsFragment = {
type Mutation (line 5856) | interface Mutation {
type UserFieldsFragment (line 5914) | type UserFieldsFragment = {
type Mutation (line 5918) | interface Mutation {
type UserFieldsFragment (line 5986) | type UserFieldsFragment = {
type Mutation (line 5990) | interface Mutation {
type UserFieldsFragment (line 6037) | type UserFieldsFragment = {
type Mutation (line 6041) | interface Mutation {
type UserFieldsFragment (line 6098) | type UserFieldsFragment = {
type Mutation (line 6102) | interface Mutation {
type UserFieldsFragment (line 6178) | type UserFieldsFragment = {
type Mutation (line 6182) | interface Mutation {
type UserFieldsFragment (line 6247) | type UserFieldsFragment = {
type Mutation (line 6251) | interface Mutation {
type UserFieldsFragment (line 6313) | type UserFieldsFragment = {
type Mutation (line 6317) | interface Mutation {
type UserFieldsFragment (line 6379) | type UserFieldsFragment = {
type ProfileFieldsFragment (line 6384) | type ProfileFieldsFragment = {
type Mutation (line 6388) | interface Mutation {
FILE: src/__tests__/exports.ts
type Namespace (line 52) | type Namespace = object;
function check (line 57) | function check(id: string, ns: Namespace) {
function checkWithConditions (line 63) | function checkWithConditions(id: string, conditions: string[]) {
FILE: src/__tests__/fetchMore.ts
type TCommentData (line 182) | type TCommentData = {
type TCommentVars (line 192) | type TCommentVars = {
function setup (line 263) | function setup(...mockedResponses: MockLink.MockedResponse[]) {
function setupWithCacheConfig (line 296) | function setupWithCacheConfig(
function makeClient (line 644) | function makeClient(): {
function checkCacheExtract1234678 (line 699) | function checkCacheExtract1234678(cache: ApolloCache) {
method merge (line 1517) | merge(_, incoming) {
function count (line 1570) | function count(): number {
type TEmptyItems (line 1589) | type TEmptyItems = {
type TEntryComments (line 1892) | type TEntryComments = {
type TEntryVars (line 1902) | type TEntryVars = {
function setup (line 1960) | function setup(...mockedResponses: MockLink.MockedResponse[]) {
function setupWithCacheConfig (line 1993) | function setupWithCacheConfig(
method updateQuery (line 2587) | updateQuery(previousQueryResult: any, options) {
function commentsInRange (line 2808) | function commentsInRange(
FILE: src/__tests__/local-state/export.ts
method postCount (line 103) | postCount(_, { authorId }) {
method postCount (line 152) | postCount(_, { authorId }) {
method currentReviewer (line 448) | currentReviewer() {
method topPost (line 513) | topPost() {
method currentFilter (line 639) | currentFilter() {
method doubleWidgets (line 984) | doubleWidgets(_, { widgetCount }) {
FILE: src/__tests__/local-state/general.ts
constant WARNINGS (line 29) | const WARNINGS = {
method selectedItemId (line 411) | selectedItemId() {
method select (line 416) | select(_, { itemId }) {
method titleLength (line 503) | titleLength(data) {
method clientEntity (line 508) | clientEntity(_root, { id }, { client }) {
method addOrUpdate (line 518) | addOrUpdate(_root, { id, title }, { client }) {
type Todo (line 782) | interface Todo {
method isSelected (line 910) | isSelected(source) {
method update (line 1367) | update(proxy, { data: { updateUser } }) {
FILE: src/__tests__/local-state/resolvers.ts
function randomDelay (line 509) | function randomDelay(range: number) {
function uuid (line 515) | function uuid() {
function times (line 521) | function times<T>(n: number, thunk: () => T): Promise<T[]> {
method developer (line 538) | async developer(_, { id }) {
method tickets (line 549) | async tickets(developer) {
method comments (line 559) | async comments(ticket) {
function check (line 572) | function check(result: ApolloClient.QueryResult<any>) {
method next (line 602) | next(result) {
method start (line 699) | start(_data, _args, { client }) {
method start (line 739) | start() {
method start (line 801) | start() {
method isInCart (line 1031) | isInCart() {
method isLoggedIn (line 1109) | isLoggedIn() {
method isLoggedIn (line 1153) | isLoggedIn() {
method name (line 1190) | name() {
method isLoggedIn (line 1194) | isLoggedIn() {
method isUserLoggedIn (line 1235) | isUserLoggedIn() {
method userData (line 1287) | userData() {
method fullName (line 1296) | fullName(data) {
method isLoggedIn (line 1402) | isLoggedIn() {
method isLoggedIn (line 1451) | isLoggedIn() {
method sessionCount (line 1454) | sessionCount() {
FILE: src/__tests__/mutationResults.ts
function setupObsQuery (line 126) | function setupObsQuery(...mockedResponses: MockLink.MockedResponse[]) {
function setupDelayObsQuery (line 156) | function setupDelayObsQuery(delay: number, ...mockedResponses: any[]) {
type Data (line 266) | interface Data {
method next (line 743) | next(res: any) {
method read (line 808) | read(ms: number = Date.now()) {
method merge (line 812) | merge(existing, incoming: number) {
method update (line 826) | update(
method read (line 884) | read(ms: number = Date.now()) {
method merge (line 888) | merge(existing, incoming: number) {
method update (line 903) | update(
method read (line 963) | read(ms: number = Date.now()) {
method merge (line 967) | merge(existing, incoming: number) {
method update (line 982) | update(
FILE: src/__tests__/optimistic.ts
function setup (line 113) | async function setup(...mockedResponses: MockLink.MockedResponse[]) {
function checkBothMutationsAreApplied (line 325) | function checkBothMutationsAreApplied(
function checkBothMutationsAreApplied (line 548) | function checkBothMutationsAreApplied(
type IMutationResult (line 1037) | type IMutationResult = {
method todoList (line 1135) | todoList(prev: any, options: any) {
function makeItem (line 1920) | function makeItem(source: string) {
type Item (line 1927) | type Item = ReturnType<typeof makeItem>;
type Data (line 1928) | type Data = { items: Item[] };
function append (line 1930) | function append(cache: ApolloCache, item: Item) {
method callback (line 1949) | callback(diff) {
method callback (line 1959) | callback(diff) {
function setup (line 2258) | async function setup(...mockedResponses: MockLink.MockedResponse[]) {
type IMutationResult (line 2314) | type IMutationResult = {
FILE: src/__tests__/refetchQueries.ts
method updateCache (line 26) | updateCache(cache) {
function makeClient (line 61) | function makeClient() {
function unsubscribe (line 89) | function unsubscribe() {
function setup (line 93) | function setup(client = makeClient()) {
function sortObjects (line 117) | function sortObjects<T extends object[]>(array: T) {
function obsUpdatedCheck (line 127) | function obsUpdatedCheck(cb: OnQueryUpdated<any>) {
method updateCache (line 157) | updateCache(cache) {
method updateCache (line 185) | updateCache(cache) {
method updateCache (line 219) | updateCache(cache) {
method updateCache (line 251) | updateCache(cache) {
method updateCache (line 290) | updateCache(cache) {
method updateCache (line 323) | updateCache(cache) {
method updateCache (line 364) | updateCache(cache) {
method updateCache (line 394) | updateCache(cache) {
method next (line 451) | next(result) {
method updateCache (line 619) | updateCache(cache) {
method updateCache (line 862) | updateCache(cache) {
method callback (line 894) | callback(diff) {
method updateCache (line 912) | updateCache(cache) {
method updateCache (line 990) | updateCache(cache) {
FILE: src/__tests__/resultCacheCleaning.ts
type Resolvers (line 7) | type Resolvers = Parameters<typeof makeExecutableSchema>[0]["resolvers"];
function uuid (line 54) | function uuid(label: string) {
function emptyList (line 58) | function emptyList(len: number) {
method chat (line 96) | chat(_, { id }) {
method id (line 101) | id(id) {
method name (line 104) | name(id) {
method messages (line 107) | messages() {
method members (line 110) | members() {
method author (line 116) | author() {
method reactions (line 119) | reactions() {
method viewedBy (line 122) | viewedBy() {
method author (line 134) | author() {
FILE: src/__tests__/subscribeToMore.ts
type SubscriptionData (line 61) | interface SubscriptionData {
type TypedOperation (line 357) | interface TypedOperation extends ApolloLink.Operation {
type TypedSubscriptionVariables (line 366) | interface TypedSubscriptionVariables {
type TData (line 379) | type TData = (typeof typedReq)["result"]["data"];
type TVariables (line 380) | type TVariables = (typeof typedReq)["request"]["variables"];
FILE: src/cache/core/__tests__/cache.ts
class TestCache (line 11) | class TestCache extends ApolloCache {
method constructor (line 12) | constructor() {
method diff (line 16) | public diff<T>(query: Cache.DiffOptions<T>): Cache.DiffResult<T> {
method evict (line 20) | public evict(): boolean {
method extract (line 24) | public extract(optimistic?: boolean): unknown {
method fragmentMatches (line 28) | public fragmentMatches(
method performTransaction (line 35) | public performTransaction(transaction: (c: ApolloCache) => void): void {
method read (line 39) | public read<
method recordOptimisticTransaction (line 46) | public recordOptimisticTransaction(
method removeOptimistic (line 51) | public removeOptimistic(id: string): void {}
method reset (line 53) | public reset(): Promise<void> {
method restore (line 57) | public restore(serializedState: unknown) {
method watch (line 61) | public watch<
method write (line 68) | public write<
method prop1 (line 378) | prop1(field) {
method prop2 (line 382) | prop2(field) {
method child (line 386) | child(field) {
method children (line 392) | children(field) {
method p1 (line 411) | p1() {
method p2 (line 415) | p2() {
method p3 (line 419) | p3() {}
method p4 (line 420) | p4(_, { DELETE }) {
method p5 (line 423) | p5(_, { INVALIDATE }) {
type ParentEntity (line 430) | interface ParentEntity {
type ChildEntity (line 435) | interface ChildEntity {
type OtherChildEntry (line 440) | interface OtherChildEntry {
method fields (line 448) | fields(field) {
method fields (line 458) | fields(field) {
type ParentEntity (line 467) | type ParentEntity = {
type ChildEntity (line 472) | type ChildEntity = {
type OtherChildEntry (line 477) | type OtherChildEntry = {
method fields (line 485) | fields(field) {
method fields (line 495) | fields(field) {
method fields (line 507) | fields(field) {
method p1 (line 518) | p1(field) {
method union (line 547) | union(field) {
method union (line 570) | union(field) {
FILE: src/cache/core/__tests__/cache.watchFragment/types.test.ts
type Item (line 13) | interface Item {
FILE: src/cache/core/cache.ts
type Transaction (line 52) | type Transaction = (c: ApolloCache) => void;
type FromOptionValue (line 58) | type FromOptionValue<TData> =
type WatchFragmentOptions (line 67) | interface WatchFragmentOptions<
type WatchFragmentResult (line 118) | type WatchFragmentResult<TData = unknown> =
type ObservableFragment (line 152) | interface ObservableFragment<TData = unknown>
method lookupFragment (line 240) | public lookupFragment(fragmentName: string): FragmentDefinitionNode | nu...
method batch (line 315) | public batch<U>(options: Cache.BatchOptions<this, U>): U {
method recordOptimisticTransaction (line 340) | public recordOptimisticTransaction(
method transformDocument (line 351) | public transformDocument(document: DocumentNode): DocumentNode {
method transformForLink (line 357) | public transformForLink(document: DocumentNode): DocumentNode {
method identify (line 361) | public identify(object: StoreObject | Reference): string | undefined {
method gc (line 365) | public gc(): string[] {
method modify (line 369) | public modify<Entity extends Record<string, any> = Record<string, any>>(
method readQuery (line 403) | public readQuery<
method watchFragment (line 474) | public watchFragment<
method watchSingleFragment (line 611) | private watchSingleFragment<
method readFragment (line 763) | public readFragment<
method writeQuery (line 798) | public writeQuery<
method writeFragment (line 834) | public writeFragment<
method updateQuery (line 855) | public updateQuery<
method updateFragment (line 873) | public updateFragment<
method toCacheId (line 891) | private toCacheId(from: ApolloCache.FromOptionValue<any>) {
FILE: src/cache/core/types/Cache.ts
type WatchCallback (line 18) | type WatchCallback<TData = unknown> = (
type ReadOptions (line 23) | interface ReadOptions<
type WriteOptions (line 51) | interface WriteOptions<
type DiffOptions (line 89) | interface DiffOptions<
type WatchOptions (line 98) | interface WatchOptions<
type EvictOptions (line 108) | interface EvictOptions {
type ResetOptions (line 117) | interface ResetOptions {
type ModifyOptions (line 121) | interface ModifyOptions<
type BatchOptions (line 130) | interface BatchOptions<
type ReadQueryOptions (line 176) | interface ReadQueryOptions<
type ReadFragmentOptions (line 212) | type ReadFragmentOptions<
type WriteQueryOptions (line 251) | interface WriteQueryOptions<
type WriteFragmentOptions (line 297) | type WriteFragmentOptions<
type UpdateQueryOptions (line 338) | interface UpdateQueryOptions<
type UpdateFragmentOptions (line 347) | type UpdateFragmentOptions<
type DiffResult (line 357) | type DiffResult<TData> =
type CacheIdentifierOption (line 371) | type CacheIdentifierOption<TData> =
FILE: src/cache/core/types/common.ts
type SafeReadonly (line 21) | type SafeReadonly<T> = T extends object ? Readonly<T> : T;
type MissingTree (line 23) | type MissingTree =
class MissingFieldError (line 29) | class MissingFieldError extends Error {
method constructor (line 30) | constructor(
type FieldSpecifier (line 57) | interface FieldSpecifier {
type ReadFieldOptions (line 65) | interface ReadFieldOptions extends FieldSpecifier {
type ReadFieldFunction (line 69) | interface ReadFieldFunction {
type ToReferenceFunction (line 77) | type ToReferenceFunction = (
type CanReadFunction (line 82) | type CanReadFunction = (value: StoreValue) => boolean;
type DeleteModifier (line 85) | interface DeleteModifier {
type InvalidateModifier (line 89) | interface InvalidateModifier {
type IgnoreModifier (line 93) | interface IgnoreModifier {
type ModifierDetails (line 97) | type ModifierDetails = {
type Modifier (line 109) | type Modifier<T> = (
type StoreObjectValueMaybeReference (line 114) | type StoreObjectValueMaybeReference<StoreVal> =
type AllFieldsModifier (line 124) | type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<
type Modifiers (line 130) | type Modifiers<T extends Record<string, any> = Record<string, unknown>> =
FILE: src/cache/deprecated.ts
type WatchFragmentOptions (line 4) | type WatchFragmentOptions<
type WatchFragmentResult (line 10) | type WatchFragmentResult<TData> = ApolloCache.WatchFragmentResult<TData>;
FILE: src/cache/inmemory/__tests__/cache.ts
function itWithInitialData (line 20) | function itWithInitialData(
function itWithCacheConfig (line 42) | function itWithCacheConfig(
type QueryData (line 1564) | type QueryData = {
method callback (line 1583) | callback(diff) {
type Data (line 1725) | type Data = { a: number; b: number; __typename: "Foo" };
function update (line 1735) | function update(data: Data | null): Data {
function watch (line 1810) | function watch(cache: InMemoryCache, query: DocumentNode) {
method update (line 1852) | update(cache) {
method onWatchUpdated (line 1862) | onWatchUpdated(w, diff) {
method update (line 1895) | update(cache) {
method onWatchUpdated (line 1905) | onWatchUpdated(w, diff) {
method update (line 1981) | update(cache) {
method onWatchUpdated (line 1992) | onWatchUpdated(w, diff) {
method update (line 2068) | update(cache) {
method onWatchUpdated (line 2079) | onWatchUpdated(watch, diff) {
method update (line 2166) | update(c) {
method update (line 2183) | update(c) {
method update (line 2193) | update(c) {
method onWatchUpdated (line 2204) | onWatchUpdated() {
method update (line 2213) | update(c) {
method update (line 2222) | update(c) {
method onWatchUpdated (line 2233) | onWatchUpdated() {
method update (line 2243) | update(c) {
method update (line 2252) | update(c) {
method update (line 2271) | update(c) {
method onWatchUpdated (line 2282) | onWatchUpdated() {
function watch (line 2412) | function watch(arg: number) {
function write (line 2428) | function write(arg: number, name: string) {
method fields (line 2571) | fields(value, { fieldName }) {
method a (line 2621) | a(value) {
method b (line 2624) | b(value) {
method __typename (line 2627) | __typename(t: string, { readField }) {
function read (line 2699) | function read() {
method name (line 2714) | name(_, { INVALIDATE }) {
method fields (line 2732) | fields(_, { INVALIDATE }) {
method yearOfBirth (line 2821) | yearOfBirth(yob) {
method author (line 2848) | author(author: Reference, { readField }) {
method __typename (line 2919) | __typename(_, { DELETE }) {
method name (line 2922) | name(_, { DELETE }) {
method merge (line 2955) | merge(
method read (line 2972) | read(existing: Reference[], { args }) {
method comments (line 3068) | comments(comments: readonly Reference[], { readField }) {
method b (line 3138) | b(value, { DELETE }) {
method fields (line 3155) | fields(value, { fieldName }) {
method callback (line 3231) | callback(data) {
method callback (line 3241) | callback(data) {
function makeResult (line 3246) | function makeResult(
method value (line 3274) | value(x: number) {
method value (line 3288) | value(x: number) {
function addBook (line 3329) | function addBook(isbn: string, title: string) {
function check (line 3388) | function check(isbnToDelete?: string) {
function check (line 3529) | function check(id: any) {
type Book (line 3563) | interface Book {
method books (line 3598) | books(existingBooks, { toReference }) {
type Book (line 3625) | type Book = {
method books (line 3660) | books(existingBooks, { toReference }) {
type User (line 3712) | type User = {
method me (line 3739) | me(existingUser, { toReference }) {
function makeCacheAndVar (line 3770) | function makeCacheAndVar(resultCaching: boolean) {
method callback (line 3883) | callback(diff) {
function watch (line 3924) | function watch(id: string) {
method callback (line 4041) | callback(diff) {
method name (line 4101) | name() {
method callback (line 4134) | callback(diff) {
method callback (line 4207) | callback(diff) {
type Book (line 4328) | type Book = {
function getBookCache (line 4378) | function getBookCache() {
FILE: src/cache/inmemory/__tests__/diffAgainstStore.ts
method dataIdFromObject (line 575) | dataIdFromObject(obj: any) {
method person (line 1060) | person(_, { args, isReference, toReference, readField }) {
function check (line 1207) | function check(store: NormalizedCache) {
FILE: src/cache/inmemory/__tests__/entityStore.ts
function newBookAuthorCache (line 70) | function newBookAuthorCache() {
function checkFalsyEvictId (line 656) | function checkFalsyEvictId(id: any) {
function withoutPublisherOfBook (line 1022) | function withoutPublisherOfBook(obj: Record<string, any>) {
function diff (line 1641) | function diff(query: DocumentNode) {
function writeInitialData (line 1700) | function writeInitialData(cache: ApolloCache) {
method book (line 1851) | book(_, { args, toReference, readField }) {
method merge (line 1869) | merge(
method title (line 2109) | title(title: string, { isReference, toReference, readField }) {
method favorited (line 2160) | favorited(_, { readField, toReference }) {
method book (line 2176) | book(_, { args, toReference }) {
method read (line 2282) | read(book, { args, toReference }) {
method callback (line 2321) | callback(diff) {
FILE: src/cache/inmemory/__tests__/fragmentMatcher.ts
function checkTypes (line 266) | function checkTypes(expected: Record<string, Record<string, boolean>>) {
FILE: src/cache/inmemory/__tests__/helpers.ts
function defaultNormalizedCacheFactory (line 12) | function defaultNormalizedCacheFactory(
type WriteQueryToStoreOptions (line 23) | interface WriteQueryToStoreOptions extends Cache.WriteOptions {
function readQueryFromStore (line 28) | function readQueryFromStore<T = any>(
function writeQueryToStore (line 38) | function writeQueryToStore(
function withError (line 55) | function withError(func: Function, regex?: RegExp) {
FILE: src/cache/inmemory/__tests__/key-extractor.ts
function check (line 14) | function check(specifier: KeySpecifier, expected: string[][]) {
function collect (line 68) | function collect(specifier: KeySpecifier) {
function check (line 74) | function check(specifier: KeySpecifier, expected: Record<string, any>) {
FILE: src/cache/inmemory/__tests__/optimistic.ts
method dataIdFromObject (line 9) | dataIdFromObject(value: any) {
function readOptimistic (line 30) | function readOptimistic(cache: InMemoryCache) {
function readRealistic (line 34) | function readRealistic(cache: InMemoryCache) {
method dataIdFromObject (line 209) | dataIdFromObject(value: any) {
type Q (line 219) | type Q = {
function read (line 278) | function read() {
function readWithAuthors (line 349) | function readWithAuthors(optimistic = true) {
function withoutISBN (line 358) | function withoutISBN(data: any) {
function readSpinelessFragment (line 415) | function readSpinelessFragment() {
function write (line 456) | function write(value: number) {
function expectOptimisticCount (line 467) | function expectOptimisticCount(value: number) {
function expectNonOptimisticCount (line 489) | function expectNonOptimisticCount(value: number) {
method update (line 519) | update() {
method update (line 534) | update() {
method update (line 543) | update() {
function expectOptimisticEviction (line 557) | function expectOptimisticEviction() {
FILE: src/cache/inmemory/__tests__/policies.ts
function reverse (line 27) | function reverse(s: string) {
function checkAuthorName (line 53) | function checkAuthorName(cache: InMemoryCache) {
method keyFields (line 342) | keyFields(book, context) {
method keyFields (line 476) | keyFields(incoming) {
method isPurchased (line 486) | isPurchased() {
method merge (line 554) | merge(_, incoming) {
method venomous (line 566) | venomous(status = "unknown") {
method read (line 678) | read(existing: any) {
method read (line 687) | read(existing) {
method merge (line 756) | merge(existing, incoming) {
type Coworker (line 772) | type Coworker = {
type CoworkerWithAlias (line 833) | interface CoworkerWithAlias extends Omit<Coworker, "uid"> {
method a (line 1042) | a() {
method read (line 1052) | read() {
method merge (line 1063) | merge(existing, incoming: string) {
method keyArgs (line 1073) | keyArgs() {
method read (line 1076) | read(existing: string) {
method merge (line 1079) | merge(existing: string, incoming: string) {
method read (line 1089) | read(existing: string) {
method merge (line 1092) | merge(existing: string, incoming: string) {
method types (line 1109) | types(existing: any[], { args }) {
function check (line 1273) | function check<
method writings (line 1416) | writings(value, { storeFieldName }) {
method keyArgs (line 1443) | keyArgs(args, context) {
method read (line 1687) | read(existing, { args, variables }) {
method result (line 1797) | result(existing, { args, storage }) {
function compute (line 1808) | function compute() {
method fullName (line 1934) | fullName(_, { readField }) {
method read (line 2018) | read(_, { readField }) {
method read (line 2023) | read(_, { variables }) {
method merge (line 2094) | merge(existing: any[] = [], incoming: any[]) {
method read (line 2105) | read(_, { storage }) {
method merge (line 2111) | merge(_, incoming: string, { storage }) {
function setResult (line 2228) | function setResult(jobNum: number) {
function recordStorageOnce (line 2452) | function recordStorageOnce(fieldName: string, storage: StorageType) {
function makeFieldPolicy (line 2460) | function makeFieldPolicy(): FieldPolicy<number> {
method mergeModify (line 2551) | mergeModify(value, { fieldName, storage }) {
method mergeReadModify (line 2556) | mergeReadModify(value, { fieldName, storage }) {
method merge (line 2615) | merge(existing: any[] = [], incoming: any[], { readField }) {
method read (line 2634) | read(existing: any[], { readField }) {
function addBooks (line 2689) | function addBooks(...books: (typeof programmingRustBook)[]) {
method taskCount (line 2814) | taskCount(_, { readField }) {
method read (line 2823) | read(existing = []) {
method merge (line 2827) | merge(existing: Reference[], incoming: Reference[]) {
method ownTime (line 2838) | ownTime(_, { readField }) {
method totalTime (line 2843) | totalTime(_, { readField, toReference }) {
method merge (line 2870) | merge(existing: Reference[] = [], incoming: Reference[]) {
function read (line 3007) | function read(): { agenda: any } | null {
function checkFirstFourIdentical (line 3244) | function checkFirstFourIdentical(result: ReturnType<typeof read>) {
method secret (line 3286) | secret() {
method read (line 3385) | read(existing: any[], { args, toReference, isReference }) {
method merge (line 3396) | merge(
method merge (line 4483) | merge(existing: any[], incoming: any[]) {
method merge (line 4495) | merge(existing: any[], incoming: any[]) {
method read (line 4648) | read(existing, { args, toReference }) {
function read (line 4676) | function read(isbn = "156858217X") {
function diff (line 4683) | function diff(isbn = "156858217X") {
method merge (line 4889) | merge(
function booksMergePolicy (line 4928) | function booksMergePolicy(): FieldPolicy<any[]> {
function testForceMerges (line 4955) | function testForceMerges(cache: InMemoryCache) {
function checkAuthor (line 5249) | function checkAuthor<TData>(data: TData, canBeUndefined = false) {
method merge (line 5276) | merge(existing, incoming) {
function check (line 5337) | async function check(cache: InMemoryCache) {
method merge (line 5501) | merge(existing, incoming) {
method read (line 5552) | read(name: string) {
method merge (line 5555) | merge(oldName, newName: string) {
method keyFields (line 5687) | keyFields() {
method keyArgs (line 5692) | keyArgs() {
method merge (line 5695) | merge(_, height, { args }) {
method merge (line 5772) | merge(existing: Reference[] = [], incoming: Reference[]) {
method firstBook (line 5780) | firstBook(_, { isReference, readField }) {
type BookData (line 5805) | interface BookData {
function addBook (line 5812) | function addBook(bookData: BookData) {
function readFirstBookResult (line 5905) | function readFirstBookResult() {
type Style (line 6003) | const enum Style {
method style (line 6015) | style(_, { args, readField }) {
method upperCase (line 6029) | upperCase(_, { readField }) {
method lowerCase (line 6035) | lowerCase(_, { readField }) {
method titleCase (line 6041) | titleCase(_, { readField }) {
method fullNameWithDefaults (line 6096) | fullNameWithDefaults(_, { readField }) {
method fullNameWithVoids (line 6102) | fullNameWithVoids(_, { readField }) {
method merge (line 6157) | merge(existing, incoming) {
function makeItem (line 6266) | function makeItem(id: number) {
FILE: src/cache/inmemory/__tests__/readFromStore.ts
method normal (line 778) | normal() {
method clientOnly (line 781) | clientOnly() {
method uuid (line 1203) | uuid() {
method null (line 1206) | null() {
method ducks (line 1266) | ducks(existing: Reference[] = [], { canRead }) {
method chickens (line 1269) | chickens(existing: Reference[] = [], { canRead }) {
method oxen (line 1274) | oxen(existing: Reference[] = [], { canRead }) {
function diffChickens (line 1370) | function diffChickens() {
function diffDucks (line 1429) | function diffDucks() {
function diffOxen (line 1477) | function diffOxen() {
method ducks (line 1524) | ducks(existing: Reference[] = [], { canRead }) {
function diffDucks (line 1571) | function diffDucks() {
method children (line 1636) | children(offspring: Reference[], { canRead }) {
method ruler (line 1646) | ruler(ruler, { canRead, toReference }) {
function watch (line 1705) | function watch(immediate = true) {
function devour (line 1718) | function devour(name: string) {
method ruler (line 2068) | ruler(value, { toReference }) {
method now (line 2136) | now() {
method abc (line 2140) | abc() {
FILE: src/cache/inmemory/__tests__/recordingCache.ts
function makeLayer (line 6) | function makeLayer(root: EntityStore) {
function lookup (line 10) | function lookup(store: EntityStore, dataId: string) {
FILE: src/cache/inmemory/__tests__/roundtrip.ts
function assertDeeplyFrozen (line 17) | function assertDeeplyFrozen(value: any, stack: any[] = []) {
function storeRoundtrip (line 29) | function storeRoundtrip(
FILE: src/cache/inmemory/__tests__/writeToStore.ts
method dataIdFromObject (line 42) | dataIdFromObject(object: any) {
function isOperationDefinition (line 1293) | function isOperationDefinition(
function isField (line 1299) | function isField(selection: SelectionNode): selection is FieldNode {
function isOperationDefinition (line 1360) | function isOperationDefinition(
method dataIdFromObject (line 1370) | dataIdFromObject() {
method merge (line 1553) | merge(existing, incoming, { readField, isReference }) {
method dataIdFromObject (line 1578) | dataIdFromObject(object: any) {
method merge (line 1708) | merge(existing, incoming, { args }) {
method merge (line 1904) | merge(existing, incoming, { isReference, readField }) {
method merge (line 2623) | merge(existing, incoming, { mergeObjects }) {
method merge (line 2812) | merge(_, text: string) {
function read (line 2847) | function read() {
type Data (line 2900) | type Data = {
method callback (line 2921) | callback(diff) {
function check (line 3200) | function check(
FILE: src/cache/inmemory/entityStore.ts
constant DELETE (line 39) | const DELETE = {} as DeleteModifier;
constant INVALIDATE (line 41) | const INVALIDATE = {} as InvalidateModifier;
method constructor (line 48) | constructor(
method toObject (line 64) | public toObject(): NormalizedCacheObject {
method has (line 68) | public has(dataId: string): boolean {
method get (line 72) | public get(dataId: string, fieldName: string): StoreValue {
method lookup (line 91) | protected lookup(
method merge (line 115) | public merge(older: string | StoreObject, newer: StoreObject | string): ...
method modify (line 206) | public modify(
method delete (line 343) | public delete(
method evict (line 368) | public evict(options: Cache.EvictOptions, limit: EntityStore): boolean {
method clear (line 388) | public clear(): void {
method extract (line 392) | public extract(): NormalizedCacheObject {
method replace (line 406) | public replace(newData: NormalizedCacheObject | null): void {
method retain (line 435) | public retain(rootId: string): number {
method release (line 439) | public release(rootId: string): number {
method getRootIdSet (line 450) | public getRootIdSet(ids = new Set<string>()) {
method gc (line 467) | public gc() {
method findChildRefIds (line 495) | public findChildRefIds(dataId: string): Record<string, true> {
method makeCacheKey (line 554) | public makeCacheKey() {
method supportsResultCaching (line 603) | public get supportsResultCaching(): boolean {
type FieldValueGetter (line 608) | type FieldValueGetter = EntityStore["getFieldValue"];
class CacheGroup (line 623) | class CacheGroup {
method constructor (line 630) | constructor(
method resetCaching (line 637) | public resetCaching() {
method depend (line 642) | public depend(dataId: string, storeFieldName: string) {
method dirty (line 660) | public dirty(dataId: string, storeFieldName: string) {
function makeDepKey (line 677) | function makeDepKey(dataId: string, storeFieldName: string) {
function maybeDependOnExistenceOfEntity (line 684) | function maybeDependOnExistenceOfEntity(
class Root (line 701) | class Root extends EntityStore {
method constructor (line 702) | constructor({
method addLayer (line 717) | public addLayer(layerId: string, replay: (layer: EntityStore) => any):...
method removeLayer (line 724) | public removeLayer(): Root {
method getStorage (line 730) | public getStorage(): StorageType {
class Layer (line 738) | class Layer extends EntityStore {
method constructor (line 739) | constructor(
method addLayer (line 749) | public addLayer(layerId: string, replay: (layer: EntityStore) => any):...
method removeLayer (line 753) | public removeLayer(layerId: string): EntityStore {
method toObject (line 810) | public toObject(): NormalizedCacheObject {
method findChildRefIds (line 817) | public findChildRefIds(dataId: string): Record<string, true> {
method getStorage (line 827) | public getStorage(
class Stump (line 840) | class Stump extends Layer {
method constructor (line 841) | constructor(root: Root) {
method removeLayer (line 850) | public removeLayer() {
method merge (line 855) | public merge(older: string | StoreObject, newer: string | StoreObject) {
function storeObjectReconciler (line 865) | function storeObjectReconciler(
function supportsResultCaching (line 880) | function supportsResultCaching(store: any): store is EntityStore {
FILE: src/cache/inmemory/fragmentRegistry.ts
type FragmentRegistryAPI (line 19) | interface FragmentRegistryAPI {
function createFragmentRegistry (line 32) | function createFragmentRegistry(
class FragmentRegistry (line 38) | class FragmentRegistry implements FragmentRegistryAPI {
method constructor (line 44) | constructor(...fragments: DocumentNode[]) {
method register (line 51) | public register(...fragments: DocumentNode[]): this {
method invalidate (line 70) | private invalidate(name: string) {}
method resetCaches (line 72) | public resetCaches() {
method lookup (line 104) | public lookup(fragmentName: string): FragmentDefinitionNode | null {
method transform (line 108) | public transform<D extends DocumentNode>(document: D): D {
method findFragmentSpreads (line 164) | public findFragmentSpreads(root: ASTNode): FragmentSpreadMap {
type FragmentSpreadMap (line 177) | interface FragmentSpreadMap {
FILE: src/cache/inmemory/helpers.ts
function defaultDataIdFromObject (line 35) | function defaultDataIdFromObject(
function normalizeConfig (line 67) | function normalizeConfig(config: InMemoryCacheConfig) {
function getTypenameFromStoreObject (line 71) | function getTypenameFromStoreObject(
function fieldNameFromStoreName (line 82) | function fieldNameFromStoreName(storeFieldName: string): string {
function selectionSetMatchesResult (line 87) | function selectionSetMatchesResult(
function storeValueIsStoreObject (line 121) | function storeValueIsStoreObject(
function makeProcessedFieldsMerger (line 127) | function makeProcessedFieldsMerger() {
function extractFragmentContext (line 131) | function extractFragmentContext(
FILE: src/cache/inmemory/inMemoryCache.ts
type BroadcastOptions (line 40) | type BroadcastOptions = Pick<
class InMemoryCache (line 45) | class InMemoryCache extends ApolloCache {
method constructor (line 73) | constructor(config: InMemoryCacheConfig = {}) {
method init (line 87) | private init() {
method resetResultCache (line 106) | private resetResultCache() {
method restore (line 159) | public restore(data: NormalizedCacheObject): this {
method extract (line 168) | public extract(optimistic: boolean = false): NormalizedCacheObject {
method read (line 182) | public read<TData = unknown>(
method write (line 204) | public write<
method modify (line 218) | public modify<Entity extends Record<string, any> = Record<string, any>>(
method diff (line 249) | public diff<
method watch (line 261) | public watch<
method gc (line 296) | public gc(options?: {
method retain (line 317) | public retain(rootId: string, optimistic?: boolean): number {
method release (line 326) | public release(rootId: string, optimistic?: boolean): number {
method identify (line 336) | public identify(object: StoreObject | Reference): string | undefined {
method evict (line 345) | public evict(options: Cache.EvictOptions): boolean {
method reset (line 371) | public reset(options?: Cache.ResetOptions): Promise<void> {
method removeOptimistic (line 395) | public removeOptimistic(idToRemove: string) {
method batch (line 408) | public batch<TUpdateResult>(
method performTransaction (line 509) | public performTransaction(
method transformDocument (line 519) | public transformDocument(document: DocumentNode): DocumentNode {
method fragmentMatches (line 525) | public fragmentMatches(
method lookupFragment (line 532) | public lookupFragment(fragmentName: string): FragmentDefinitionNode | ...
method resolvesClientField (line 536) | public resolvesClientField(typename: string, fieldName: string): boole...
method broadcastWatches (line 540) | protected broadcastWatches(options?: BroadcastOptions) {
method addFragmentsToDocument (line 556) | private addFragmentsToDocument(document: DocumentNode) {
method broadcastWatch (line 567) | private broadcastWatch(c: Cache.WatchOptions, options?: BroadcastOptio...
FILE: src/cache/inmemory/key-extractor.ts
function lookupSpecifierInfo (line 27) | function lookupSpecifierInfo(spec: KeySpecifier) {
function keyFieldsFnFromSpecifier (line 35) | function keyFieldsFnFromSpecifier(
function keyArgsFnFromSpecifier (line 98) | function keyArgsFnFromSpecifier(
function collectSpecifierPaths (line 179) | function collectSpecifierPaths(
function getSpecifierPaths (line 200) | function getSpecifierPaths(spec: KeySpecifier): string[][] {
function extractKey (line 224) | function extractKey<TObj extends Record<string, any>, TKey extends string>(
function extractKeyPath (line 231) | function extractKeyPath(
function normalize (line 257) | function normalize<T>(value: T): T {
FILE: src/cache/inmemory/policies.ts
type TypePolicies (line 65) | type TypePolicies = {
type KeySpecifier (line 71) | type KeySpecifier = ReadonlyArray<string | KeySpecifier>;
type KeyFieldsContext (line 73) | type KeyFieldsContext = {
type KeyFieldsFunction (line 108) | type KeyFieldsFunction = (
type KeyFieldsResult (line 113) | type KeyFieldsResult = Exclude<ReturnType<KeyFieldsFunction>, KeySpecifi...
type TypePolicy (line 117) | type TypePolicy = {
type KeyArgsFunction (line 143) | type KeyArgsFunction = (
type FieldPolicy (line 153) | type FieldPolicy<
type StorageType (line 178) | type StorageType = Record<string, any>;
function argsFromFieldSpecifier (line 180) | function argsFromFieldSpecifier(spec: FieldSpecifier) {
type FieldFunctionOptions (line 188) | interface FieldFunctionOptions<
type FieldReadFunctionOptions (line 243) | interface FieldReadFunctionOptions<
type FieldMergeFunctionOptions (line 248) | interface FieldMergeFunctionOptions<
type MergeObjectsFunction (line 277) | type MergeObjectsFunction = <T extends StoreObject | Reference>(
type FieldReadFunction (line 282) | type FieldReadFunction<
type FieldMergeFunction (line 299) | type FieldMergeFunction<
type PossibleTypesMap (line 348) | type PossibleTypesMap = {
type InternalFieldPolicy (line 352) | type InternalFieldPolicy = {
class Policies (line 359) | class Policies {
method constructor (line 393) | constructor(
method identify (line 421) | public identify(
method addTypePolicies (line 481) | public addTypePolicies(typePolicies: TypePolicies) {
method updateTypePolicy (line 512) | private updateTypePolicy(
method setRootTypename (line 601) | private setRootTypename(
method addPossibleTypes (line 623) | public addPossibleTypes(possibleTypes: PossibleTypesMap) {
method getTypePolicy (line 642) | private getTypePolicy(typename: string): Policies["typePolicies"][stri...
method getFieldPolicy (line 720) | private getFieldPolicy(
method getSupertypeSet (line 729) | private getSupertypeSet(
method fragmentMatches (line 740) | public fragmentMatches(
method hasKeyArgs (line 838) | public hasKeyArgs(typename: string | undefined, fieldName: string) {
method getStoreFieldName (line 843) | public getStoreFieldName(fieldSpec: FieldSpecifier): string {
method readField (line 890) | public readField<V = StoreValue>(
method getReadFunction (line 941) | public getReadFunction(
method getMergeFunction (line 949) | public getMergeFunction(
method runMergeFunction (line 966) | public runMergeFunction(
function makeFieldFunctionOptions (line 1056) | function makeFieldFunctionOptions(
function makeMergeFieldFunctionOptions (line 1089) | function makeMergeFieldFunctionOptions(
function normalizeReadFieldOptions (line 1128) | function normalizeReadFieldOptions(
function makeMergeObjectsFunction (line 1168) | function makeMergeObjectsFunction(
FILE: src/cache/inmemory/reactiveVars.ts
type ReactiveVar (line 8) | interface ReactiveVar<T> {
type ReactiveListener (line 15) | type ReactiveListener<T> = (value: T) => any;
function getCacheInfo (line 29) | function getCacheInfo(cache: ApolloCache) {
function forgetCache (line 43) | function forgetCache(cache: ApolloCache) {
function recallCache (line 55) | function recallCache(cache: ApolloCache) {
function makeVar (line 59) | function makeVar<T>(value: T): ReactiveVar<T> {
type Broadcastable (line 113) | type Broadcastable = ApolloCache & {
function broadcast (line 119) | function broadcast(cache: Broadcastable) {
FILE: src/cache/inmemory/readFromStore.ts
type ReadContext (line 60) | interface ReadContext extends ReadMergeModifyContext {
type ExecResult (line 67) | type ExecResult<R = any> = {
type ExecSelectionSetOptions (line 72) | type ExecSelectionSetOptions = {
type ExecSubSelectedArrayOptions (line 79) | type ExecSubSelectedArrayOptions = {
type StoreReaderConfig (line 86) | interface StoreReaderConfig {
type ExecSelectionSetKeyArgs (line 92) | type ExecSelectionSetKeyArgs = [
function execSelectionSetKeyArgs (line 98) | function execSelectionSetKeyArgs(
class StoreReader (line 104) | class StoreReader {
method constructor (line 126) | constructor(config: StoreReaderConfig) {
method diffQueryAgainstStore (line 198) | public diffQueryAgainstStore<T>({
method isFresh (line 253) | public isFresh(
method execSelectionSetImpl (line 276) | private execSelectionSetImpl({
method execSubSelectedArrayImpl (line 411) | private execSubSelectedArrayImpl({
function firstMissing (line 479) | function firstMissing(tree: MissingTree): string | undefined {
function assertSelectionSetForIdValue (line 490) | function assertSelectionSetForIdValue(
FILE: src/cache/inmemory/types.ts
type IdGetterObj (line 31) | interface IdGetterObj extends Object {
type IdGetter (line 37) | type IdGetter = (value: IdGetterObj) => string | undefined;
type NormalizedCache (line 43) | interface NormalizedCache {
type NormalizedCacheObject (line 96) | interface NormalizedCacheObject {
type OptimisticStoreItem (line 109) | type OptimisticStoreItem = {
type ReadQueryOptions (line 115) | type ReadQueryOptions = {
type DiffQueryAgainstStoreOptions (line 130) | type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
type ApolloReducerConfig (line 134) | type ApolloReducerConfig = {
type InMemoryCacheConfig (line 138) | interface InMemoryCacheConfig extends ApolloReducerConfig {
type MergeInfo (line 145) | interface MergeInfo {
type MergeTree (line 152) | interface MergeTree {
type ReadMergeModifyContext (line 157) | interface ReadMergeModifyContext {
FILE: src/cache/inmemory/writeToStore.ts
type WriteContext (line 69) | interface WriteContext extends ReadMergeModifyContext {
type FlavorableWriteContext (line 95) | type FlavorableWriteContext = Pick<
function getContextFlavor (line 105) | function getContextFlavor<TContext extends FlavorableWriteContext>(
type ProcessSelectionSetOptions (line 128) | interface ProcessSelectionSetOptions {
class StoreWriter (line 137) | class StoreWriter {
method constructor (line 138) | constructor(
method writeToStore (line 144) | public writeToStore<
method processSelectionSet (line 270) | private processSelectionSet({
method processFieldValue (line 508) | private processFieldValue(
method flattenFields (line 547) | private flattenFields<
method applyMerges (line 672) | private applyMerges<T extends StoreValue>(
function getChildMergeTree (line 776) | function getChildMergeTree(
function mergeMergeTrees (line 786) | function mergeMergeTrees(
function mergeTreeIsEmpty (line 828) | function mergeTreeIsEmpty(tree: MergeTree | undefined): boolean {
function maybeRecycleChildMergeTree (line 832) | function maybeRecycleChildMergeTree({ map }: MergeTree, name: string | n...
function warnAboutDataLoss (line 844) | function warnAboutDataLoss(
function getTypenameFromResult (line 929) | function getTypenameFromResult(
FILE: src/config/jest/resolver.ts
function sync (line 8) | function sync(path: string, options: ResolverOptions): string {
FILE: src/config/jest/setup.ts
function fail (line 46) | function fail(reason = "fail was called in a test.") {
FILE: src/core/ApolloClient.ts
type DefaultOptions (line 66) | interface DefaultOptions {
type Options (line 72) | interface Options {
type DevtoolsOptions (line 151) | interface DevtoolsOptions {
type MutateOptions (line 167) | type MutateOptions<
type MutateResult (line 215) | interface MutateResult<TData = unknown> {
type QueryOptions (line 229) | type QueryOptions<
type QueryResult (line 246) | interface QueryResult<TData = unknown> {
type RefetchQueriesOptions (line 257) | interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
type RefetchQueriesResult (line 295) | interface RefetchQueriesResult<TResult>
type AdditionalProperties (line 300) | interface AdditionalProperties<TResult> {
type SubscribeOptions (line 317) | type SubscribeOptions<
type SubscribeResult (line 337) | interface SubscribeResult<TData = unknown> {
type WatchFragmentOptions (line 348) | type WatchFragmentOptions<
type WatchFragmentResult (line 353) | type WatchFragmentResult<TData = unknown> =
type ObservableFragment (line 356) | interface ObservableFragment<TData = unknown>
type WatchQueryOptions (line 367) | type WatchQueryOptions<
type ReadQueryOptions (line 426) | interface ReadQueryOptions<
type ReadQueryOptions (line 459) | type ReadQueryOptions<
type ReadQueryOptions (line 465) | interface ReadQueryOptions<
type ReadFragmentOptions (line 477) | interface ReadFragmentOptions<
type ReadFragmentOptions (line 513) | interface ReadFragmentOptions<
type ReadFragmentOptions (line 537) | type ReadFragmentOptions<
type WriteQueryOptions (line 545) | interface WriteQueryOptions<
type WriteQueryOptions (line 557) | interface WriteQueryOptions<
type WriteQueryOptions (line 596) | type WriteQueryOptions<
type WriteQueryOptions (line 602) | interface WriteQueryOptions<
type WriteFragmentOptions (line 614) | interface WriteFragmentOptions<
type WriteFragmentOptions (line 651) | type WriteFragmentOptions<
type WriteFragmentOptions (line 659) | interface WriteFragmentOptions<
type Experiment (line 688) | interface Experiment {
class ApolloClient (line 700) | class ApolloClient {
method prioritizeCacheValues (line 708) | public set prioritizeCacheValues(value: boolean) {
method prioritizeCacheValues (line 719) | public get prioritizeCacheValues() {
method constructor (line 757) | constructor(options: ApolloClient.Options) {
method connectToDevTools (line 844) | private connectToDevTools() {
method documentTransform (line 906) | get documentTransform() {
method localState (line 914) | get localState(): LocalState | undefined {
method localState (line 918) | set localState(localState: LocalState) {
method stop (line 932) | public stop() {
method watchQuery (line 955) | public watchQuery<
method query (line 982) | public query<
method mutate (line 1046) | public mutate<
method subscribe (line 1091) | public subscribe<
method readQuery (line 1151) | public readQuery<
method watchFragment (line 1236) | public watchFragment<
method readFragment (line 1308) | public readFragment<
method writeQuery (line 1326) | public writeQuery<
method writeFragment (line 1352) | public writeFragment<
method __actionHookForDevTools (line 1367) | public __actionHookForDevTools(cb: () => any) {
method __requestRaw (line 1371) | public __requestRaw(
method resetStore (line 1393) | public resetStore(): Promise<ApolloClient.QueryResult<any>[] | null> {
method clearStore (line 1408) | public clearStore(): Promise<any[]> {
method onResetStore (line 1423) | public onResetStore(cb: () => Promise<any>): () => void {
method onClearStore (line 1437) | public onClearStore(cb: () => Promise<any>): () => void {
method refetchObservableQueries (line 1480) | public refetchObservableQueries(
method refetchQueries (line 1497) | public refetchQueries<
method getObservableQueries (line 1549) | public getObservableQueries(
method extract (line 1566) | public extract(optimistic?: boolean) {
method restore (line 1577) | public restore(serializedState: unknown) {
method setLink (line 1584) | public setLink(newLink: ApolloLink) {
method defaultContext (line 1588) | public get defaultContext() {
method transform (line 1596) | private transform(document: DocumentNode, dataMasking = false) {
FILE: src/core/ObservableQuery.ts
type TrackedOperation (line 60) | interface TrackedOperation {
type EmitBehavior (line 93) | const enum EmitBehavior {
type Meta (line 113) | interface Meta {
type Options (line 120) | type Options<
type FetchMoreOptions (line 167) | type FetchMoreOptions<
type SubscribeToMoreOptions (line 190) | interface SubscribeToMoreOptions<
type CacheWatchOptions (line 215) | interface CacheWatchOptions<
type Result (line 233) | type Result<
type ResultPromise (line 257) | interface ResultPromise<T> extends Promise<T> {
type OperatorFunctionChain (line 266) | type OperatorFunctionChain<From, To> = [];
type ObservableMethods (line 267) | interface ObservableMethods<TData, OperatorResult> {
type SubjectValue (line 286) | interface SubjectValue<TData, TVariables extends OperationVariables> {
class ObservableQuery (line 293) | class ObservableQuery<
method query (line 312) | public get query(): TypedDocumentNode<TData, TVariables> {
method variables (line 319) | public get variables(): TVariables {
method networkStatus (line 358) | private get networkStatus(): NetworkStatus {
method cache (line 362) | private get cache() {
method constructor (line 366) | constructor({
method initializeObservablesQueue (line 432) | private initializeObservablesQueue() {
method getCacheDiff (line 576) | public getCacheDiff({ optimistic = true } = {}) {
method getInitialResult (line 585) | private getInitialResult(
method resubscribeCache (line 642) | private resubscribeCache() {
method getCurrentResult (line 727) | public getCurrentResult(): ObservableQuery.Result<MaybeMasked<TData>> {
method refetch (line 770) | public refetch(
method fetchMore (line 831) | public fetchMore<
method subscribeToMore (line 1101) | public subscribeToMore<
method applyOptions (line 1156) | public applyOptions(
method setVariables (line 1180) | public async setVariables(
method updateQuery (line 1214) | public updateQuery(mapFn: UpdateQueryMapFn<TData, TVariables>): void {
method startPolling (line 1241) | public startPolling(pollInterval: number) {
method stopPolling (line 1249) | public stopPolling() {
method applyNextFetchPolicy (line 1255) | private applyNextFetchPolicy(
method fetch (line 1295) | private fetch(
method updatePolling (line 1415) | private updatePolling() {
method cancelPolling (line 1508) | private cancelPolling() {
method reobserve (line 1522) | public reobserve(
method _reobserve (line 1529) | private _reobserve(
method hasObservers (line 1689) | public hasObservers() {
method stop (line 1696) | public stop() {
method tearDownQuery (line 1702) | private tearDownQuery() {
method transformDocument (line 1722) | private transformDocument(document: DocumentNode) {
method maskResult (line 1726) | private maskResult<T extends { data: any }>(result: T): T {
method resetNotifications (line 1743) | private resetNotifications() {
method scheduleNotify (line 1752) | private scheduleNotify() {
method notify (line 1761) | public notify(scheduled = false) {
method pushOperation (line 1827) | private pushOperation(networkStatus: NetworkStatus): {
method calculateNetworkStatus (line 1868) | private calculateNetworkStatus(baseNetworkStatus: NetworkStatus) {
method abortActiveOperations (line 1886) | private abortActiveOperations() {
method reset (line 1897) | public reset() {
method setResult (line 1909) | private setResult(
method reobserveCacheFirst (line 2013) | private reobserveCacheFirst(): void {
method getVariablesWithDefaults (line 2043) | private getVariablesWithDefaults(variables: TVariables | undefined) {
function logMissingFieldErrors (line 2048) | function logMissingFieldErrors(
function isEqualQuery (line 2056) | function isEqualQuery(
function getTrackingOperatorPromise (line 2063) | function getTrackingOperatorPromise<TData>(
FILE: src/core/QueryInfo.ts
type UpdateQueries (line 34) | type UpdateQueries<TData> = ApolloClient.MutateOptions<
constant IGNORE (line 40) | const IGNORE = {} as IgnoreModifier;
type CacheWriteBehavior (line 42) | const enum CacheWriteBehavior {
type LastWrite (line 48) | interface LastWrite {
type OperationInfo (line 56) | interface OperationInfo<
function wrapDestructiveCacheMethod (line 67) | function wrapDestructiveCacheMethod(
class QueryInfo (line 96) | class QueryInfo<
method constructor (line 120) | constructor(
method lastWrite (line 150) | private get lastWrite(): LastWrite | undefined {
method lastWrite (line 153) | private set lastWrite(value: LastWrite | undefined) {
method resetLastWrite (line 157) | public resetLastWrite() {
method shouldWrite (line 161) | private shouldWrite(
method hasNext (line 182) | get hasNext() {
method maybeHandleIncrementalResult (line 186) | private maybeHandleIncrementalResult(
method markQueryResult (line 211) | public markQueryResult(
method markMutationResult (line 341) | public markMutationResult(
method markMutationOptimistic (line 562) | public markMutationOptimistic(
method markSubscriptionResult (line 595) | public markSubscriptionResult(
function shouldWriteResult (line 624) | function shouldWriteResult<T>(
FILE: src/core/QueryManager.ts
type MutationStoreValue (line 99) | interface MutationStoreValue {
type TransformCacheEntry (line 106) | interface TransformCacheEntry {
type MaskFragmentOptions (line 120) | interface MaskFragmentOptions<TData> {
type MaskOperationOptions (line 126) | interface MaskOperationOptions<TData> {
type QueryManagerOptions (line 138) | interface QueryManagerOptions {
type Result (line 154) | type Result<
class QueryManager (line 163) | class QueryManager {
method constructor (line 209) | constructor(options: QueryManagerOptions) {
method link (line 243) | get link() {
method cache (line 247) | get cache() {
method stop (line 255) | public stop() {
method cancelPendingFetches (line 263) | private cancelPendingFetches(error: Error) {
method mutate (line 268) | public async mutate<
method fetchQuery (line 453) | public fetchQuery<TData, TVariables extends OperationVariables>(
method transform (line 485) | public transform(document: DocumentNode) {
method getDocumentInfo (line 497) | public getDocumentInfo(document: DocumentNode) {
method getVariables (line 554) | public getVariables<TVariables extends OperationVariables>(
method watchQuery (line 569) | public watchQuery<
method query (line 600) | public query<
method generateRequestId (line 622) | public generateRequestId() {
method clearStore (line 626) | public clearStore(
method getObservableQueries (line 656) | public getObservableQueries(
method refetchObservableQueries (line 741) | public refetchObservableQueries(
method startGraphQLSubscription (line 764) | public startGraphQLSubscription<TData = unknown>(
method broadcastQueries (line 871) | public broadcastQueries() {
method getObservableFromLink (line 883) | private getObservableFromLink<TData = unknown>(
method getResultsFromLink (line 1036) | private getResultsFromLink<TData, TVariables extends OperationVariables>(
method fetchObservableWithInfo (line 1157) | public fetchObservableWithInfo<TData, TVariables extends OperationVari...
method refetchQueries (line 1325) | public refetchQueries<TResult>({
method maskOperation (line 1510) | public maskOperation<TData = unknown>(
method maskFragment (line 1540) | public maskFragment<TData = unknown>(options: MaskFragmentOptions<TDat...
method fetchQueryByPolicy (line 1548) | private fetchQueryByPolicy<TData, TVariables extends OperationVariables>(
function validateDidEmitValue (line 1768) | function validateDidEmitValue<T>() {
type ObservableAndInfo (line 1785) | interface ObservableAndInfo<TData> {
function isFullyUnmaskedOperation (line 1791) | function isFullyUnmaskedOperation(document: DocumentNode) {
function addNonReactiveToNamedFragments (line 1809) | function addNonReactiveToNamedFragments(document: DocumentNode) {
function removeStreamDetailsFromExtensions (line 1834) | function removeStreamDetailsFromExtensions(
FILE: src/core/__tests__/ApolloClient/general.test.ts
method info (line 3091) | info(_, { DELETE }) {
method merge (line 3174) | merge(existing, incoming, { isReference, readField }) {
method next (line 3650) | next() {
method next (line 3667) | next() {
function makeClient (line 6961) | function makeClient() {
method update (line 7004) | update(cache) {
method onQueryUpdated (line 7014) | async onQueryUpdated(obsQuery) {
method update (line 7072) | update(cache) {
method onQueryUpdated (line 7082) | onQueryUpdated(obsQuery) {
method update (line 7126) | update(cache) {
method onQueryUpdated (line 7130) | onQueryUpdated(obsQuery) {
FILE: src/core/__tests__/ApolloClient/links.test.ts
method book (line 322) | book(_, { args, toReference, readField }) {
FILE: src/core/__tests__/ObservableQuery.ts
method nextFetchPolicy (line 2433) | nextFetchPolicy(currentFetchPolicy, info) {
method counter (line 2584) | counter() {
function makeMock (line 2686) | function makeMock(...vars: string[]) {
function makeMock (line 2802) | function makeMock(...vars: string[]) {
function makeMock (line 2934) | function makeMock(...variables: string[]) {
type Result (line 4000) | type Result =
type TestDetails (line 4033) | type TestDetails = {
function check (line 5231) | async function check(result: Result, expectedName: string) {
function check (line 5781) | function check({
function checkThrows (line 5829) | async function checkThrows(assumeImmutableResults: boolean) {
method update (line 6082) | update(cache) {
method onWatchUpdated (line 6094) | onWatchUpdated(watch, diff) {
type UserCountQuery (line 6281) | interface UserCountQuery {
type UserCountVariables (line 6284) | interface UserCountVariables {
method expected (line 6997) | expected(previous) {
method expected (line 7021) | expected(previous) {
FILE: src/core/__tests__/client.watchFragment/arrays.test.ts
type Item (line 6) | type Item = {
type Item (line 55) | type Item = {
type Item (line 100) | type Item = {
type Item (line 130) | type Item = {
type Item (line 173) | type Item = {
type Item (line 207) | type Item = {
type Item (line 246) | type Item = {
type Item (line 283) | type Item = {
type Item (line 333) | type Item = {
type ItemDetails (line 472) | type ItemDetails = {
type Item (line 477) | type Item = {
type Item (line 649) | type Item = {
type Item (line 822) | type Item = {
FILE: src/core/__tests__/client.watchFragment/general.test.ts
type Item (line 6) | type Item = {
type Item (line 71) | type Item = {
type Item (line 122) | type Item = {
type Item (line 157) | type Item = {
FILE: src/core/__tests__/client.watchFragment/getCurrentResult.test.ts
type Item (line 8) | interface Item {
type ItemDetails (line 420) | type ItemDetails = {
type Item (line 425) | type Item = {
type ItemDetails (line 526) | type ItemDetails = {
type Item (line 531) | type Item = {
FILE: src/core/__tests__/client.watchFragment/types.test.ts
type Item (line 13) | interface Item {
FILE: src/core/__tests__/client.watchQuery/streamDefer20220824.test.ts
function createLink (line 29) | function createLink(rootValue?: Record<string, unknown>) {
method friendList (line 385) | async *friendList() {
method friendList (line 477) | async *friendList() {
method friendList (line 534) | async *friendList() {
method nestedFriendList (line 941) | async *nestedFriendList() {
method friendList (line 1058) | async *friendList() {
FILE: src/core/__tests__/client.watchQuery/streamGraphQL17Alpha9.test.ts
type Friend (line 31) | type Friend = (typeof friends)[number];
function createLink (line 33) | function createLink(rootValue?: Record<string, unknown>) {
method friendList (line 406) | async *friendList() {
method friendList (line 498) | async *friendList() {
method friendList (line 553) | async *friendList() {
method nestedFriendList (line 688) | async *nestedFriendList() {
method friendList (line 805) | async *friendList() {
function createMockStreamMergeFn (line 2276) | function createMockStreamMergeFn() {
FILE: src/core/__tests__/fetchPolicies.ts
method hero (line 345) | hero(_data, args) {
function dataWithId (line 372) | function dataWithId(id: number | string) {
method hero (line 686) | hero(_data, args) {
function dataWithId (line 713) | function dataWithId(id: number | string) {
type TData (line 815) | type TData = {
type TVariables (line 824) | type TVariables = {
function makeLink (line 838) | function makeLink() {
type CheckOptions (line 912) | type CheckOptions = Parameters<typeof checkNextFetchPolicy>[0];
type NextFetchPolicy (line 913) | type NextFetchPolicy = CheckOptions["nextFetchPolicy"];
type CheckResultCallback (line 914) | type CheckResultCallback = CheckOptions["checkResult"];
FILE: src/core/deprecated.ts
type ApolloClientOptions (line 8) | type ApolloClientOptions = ApolloClient.Options;
type ApolloQueryResult (line 11) | type ApolloQueryResult<
type DefaultOptions (line 17) | type DefaultOptions = ApolloClient.DefaultOptions;
type DevtoolsOptions (line 20) | type DevtoolsOptions = ApolloClient.DevtoolsOptions;
type MutationOptions (line 23) | type MutationOptions<
type MutateResult (line 30) | type MutateResult<TData = unknown> = ApolloClient.MutateResult<TData>;
type QueryOptions (line 33) | type QueryOptions<
type RefetchQueriesOptions (line 40) | type RefetchQueriesOptions<
type RefetchQueriesResult (line 46) | type RefetchQueriesResult<TResult> =
type SubscribeToMoreOptions (line 50) | type SubscribeToMoreOptions<
type SubscriptionOptions (line 64) | type SubscriptionOptions<
type WatchQueryOptions (line 71) | type WatchQueryOptions<
FILE: src/core/networkStatus.ts
type NetworkStatus (line 4) | enum NetworkStatus {
FILE: src/core/types.ts
type TypeOverrides (line 23) | interface TypeOverrides {}
type Defaults (line 26) | interface Defaults {
type Complete (line 32) | interface Complete extends HKT {
type Streaming (line 37) | interface Streaming extends HKT {
type Partial (line 42) | interface Partial extends HKT {
type Complete (line 75) | type Complete<TData> = ApplyHKTImplementationWithDefault<
type Streaming (line 107) | type Streaming<TData> = ApplyHKTImplementationWithDefault<
type Partial (line 139) | type Partial<TData> = ApplyHKTImplementationWithDefault<
type DefaultContext (line 147) | interface DefaultContext extends Record<string, any> {
type ErrorLike (line 185) | interface ErrorLike {
type OnQueryUpdated (line 191) | type OnQueryUpdated<TResult> = (
type RefetchQueryDescriptor (line 197) | type RefetchQueryDescriptor = string | DocumentNode;
type InternalRefetchQueryDescriptor (line 198) | type InternalRefetchQueryDescriptor =
type RefetchQueriesIncludeShorthand (line 202) | type RefetchQueriesIncludeShorthand = "all" | "active";
type RefetchQueriesInclude (line 204) | type RefetchQueriesInclude =
type InternalRefetchQueriesInclude (line 208) | type InternalRefetchQueriesInclude =
type RefetchQueriesPromiseResults (line 217) | type RefetchQueriesPromiseResults<TResult> =
type InternalRefetchQueriesOptions (line 240) | interface InternalRefetchQueriesOptions<
type InternalRefetchQueriesResult (line 253) | type InternalRefetchQueriesResult<TResult> =
type InternalRefetchQueriesMap (line 263) | type InternalRefetchQueriesMap<TResult> = Map<
type OperationVariables (line 268) | type OperationVariables = Record<string, any>;
type DataState (line 270) | type DataState<TData> =
type GetDataState (line 296) | type GetDataState<
type NormalizedExecutionResult (line 306) | type NormalizedExecutionResult<
type MutationQueryReducer (line 313) | type MutationQueryReducer<T> = (
type MutationQueryReducersMap (line 322) | type MutationQueryReducersMap<T = { [key: string]: any }> = {
type MutationUpdaterFunction (line 326) | type MutationUpdaterFunction<
type NewNetworkStatus (line 340) | type NewNetworkStatus = NextNotification<{
type SetResult (line 346) | type SetResult<TData> = NextNotification<ObservableQuery.Result<TData>> & {
type FromNetwork (line 350) | type FromNetwork<TData> = ObservableNotification<
type FromCache (line 356) | type FromCache<TData> = NextNotification<ObservableQuery.Result<TData>> & {
type Value (line 360) | type Value<TData> =
type SubscriptionObservable (line 368) | interface SubscriptionObservable<T> extends Observable<T> {
FILE: src/core/watchQueryOptions.ts
type FetchPolicy (line 18) | type FetchPolicy =
type WatchQueryFetchPolicy (line 24) | type WatchQueryFetchPolicy =
type MutationFetchPolicy (line 29) | type MutationFetchPolicy = Extract<
type RefetchWritePolicy (line 35) | type RefetchWritePolicy = "merge" | "overwrite";
type ErrorPolicy (line 44) | type ErrorPolicy = "none" | "ignore" | "all";
type NextFetchPolicyContext (line 46) | interface NextFetchPolicyContext<
type UpdateQueryOptions (line 56) | type UpdateQueryOptions<TData, TVariables extends OperationVariables> = {
type UpdateQueryMapFn (line 76) | interface UpdateQueryMapFn<
type SubscribeToMoreUpdateQueryFn (line 91) | type SubscribeToMoreUpdateQueryFn<
type SubscribeToMoreFunction (line 109) | interface SubscribeToMoreFunction<
FILE: src/dev/loadDevMessages.ts
function loadDevMessages (line 5) | function loadDevMessages() {
FILE: src/dev/loadErrorMessageHandler.ts
function loadErrorMessageHandler (line 13) | function loadErrorMessageHandler(...errorCodes: ErrorCodes[]) {
FILE: src/dev/loadErrorMessages.ts
function loadErrorMessages (line 5) | function loadErrorMessages() {
FILE: src/dev/setErrorMessageHandler.ts
type ErrorMessageHandler (line 12) | type ErrorMessageHandler = {
function setErrorMessageHandler (line 40) | function setErrorMessageHandler(handler: ErrorMessageHandler) {
FILE: src/dev/symbol.ts
type Window (line 9) | interface Window {
FILE: src/errors/CombinedGraphQLErrors.ts
type MessageFormatterOptions (line 8) | interface MessageFormatterOptions {
type MessageFormatter (line 70) | type MessageFormatter = (
type InstanceProperties (line 97) | interface InstanceProperties {
function defaultFormatMessage (line 131) | function defaultFormatMessage(errors: ReadonlyArray<GraphQLFormattedErro...
class CombinedGraphQLErrors (line 174) | class CombinedGraphQLErrors extends Error {
method is (line 178) | static is(error: unknown): error is CombinedGraphQLErrors {
method constructor (line 201) | constructor(
FILE: src/errors/CombinedProtocolErrors.ts
type MessageFormatterOptions (line 6) | interface MessageFormatterOptions {
type MessageFormatter (line 63) | type MessageFormatter = (
type InstanceProperties (line 90) | interface InstanceProperties {
function defaultFormatMessage (line 100) | function defaultFormatMessage(errors: ReadonlyArray<GraphQLFormattedErro...
class CombinedProtocolErrors (line 130) | class CombinedProtocolErrors extends Error {
method is (line 144) | static is(error: unknown): error is CombinedProtocolErrors {
method constructor (line 155) | constructor(
FILE: src/errors/LinkError.ts
function registerLinkError (line 6) | function registerLinkError(error: ErrorLike) {
FILE: src/errors/LocalStateError.ts
type Options (line 4) | interface Options {
type InstanceProperties (line 10) | interface InstanceProperties {
class LocalStateError (line 39) | class LocalStateError extends Error {
method is (line 53) | static is(error: unknown): error is LocalStateError {
method constructor (line 60) | constructor(message: string, options: LocalStateError.Options = {}) {
FILE: src/errors/ServerError.ts
type Options (line 4) | interface Options {
type InstanceProperties (line 10) | interface InstanceProperties {
class ServerError (line 62) | class ServerError extends Error {
method is (line 76) | static is(error: unknown): error is ServerError {
method constructor (line 89) | constructor(message: string, options: ServerError.Options) {
FILE: src/errors/ServerParseError.ts
type Options (line 4) | interface Options {
type InstanceProperties (line 10) | interface InstanceProperties {
class ServerParseError (line 56) | class ServerParseError extends Error {
method is (line 70) | static is(error: unknown): error is ServerParseError {
method constructor (line 82) | constructor(originalParseError: unknown, options: ServerParseError.Opt...
FILE: src/errors/UnconventionalError.ts
class UnconventionalError (line 40) | class UnconventionalError extends Error {
method is (line 54) | static is(error: unknown): error is UnconventionalError {
method constructor (line 58) | constructor(errorType: unknown) {
FILE: src/errors/__tests__/LinkError.test.ts
function createErrorLink (line 35) | function createErrorLink(error: unknown) {
FILE: src/errors/index.ts
constant PROTOCOL_ERRORS_SYMBOL (line 8) | const PROTOCOL_ERRORS_SYMBOL: unique symbol = Symbol();
type WithSymbolExtensions (line 10) | type WithSymbolExtensions<T> = T & {
function graphQLResultHasProtocolErrors (line 14) | function graphQLResultHasProtocolErrors<T extends {}>(
function toErrorLike (line 27) | function toErrorLike(error: unknown) {
FILE: src/errors/isErrorLike.ts
function isErrorLike (line 3) | function isErrorLike(error: unknown): error is ErrorLike {
FILE: src/errors/utils.ts
function isBranded (line 1) | function isBranded(error: unknown, name: string) {
function brand (line 9) | function brand(error: Error) {
FILE: src/incremental/handlers/__tests__/defer20220824/defer.test.ts
function resolveOnNextTick (line 99) | function resolveOnNextTick(): Promise<void> {
function run (line 103) | function run(query: DocumentNode) {
FILE: src/incremental/handlers/__tests__/defer20220824/stream.test.ts
function run (line 31) | function run(document: DocumentNode, rootValue: unknown = {}) {
function createSchemaLink (line 39) | function createSchemaLink(rootValue?: Record<string, unknown>) {
method friendList (line 515) | async *friendList() {
method friendList (line 613) | async *friendList() {
method friendList (line 697) | async *friendList() {
method friendList (line 905) | async *friendList() {
method nestedFriendList (line 1011) | async *nestedFriendList() {
method deeperNestedFriendList (line 1077) | async *deeperNestedFriendList() {
method friendList (line 1136) | async *friendList() {
method friendList (line 1216) | async *friendList() {
method nestedFriendList (line 1313) | async *nestedFriendList() {
method friendList (line 1424) | async *friendList() {
method nestedFriendList (line 1849) | async *nestedFriendList() {
FILE: src/incremental/handlers/__tests__/graphql17Alpha9/defer.test.ts
function resolveOnNextTick (line 148) | function resolveOnNextTick(): Promise<void> {
function run (line 152) | function run(
function createSchemaLink (line 165) | function createSchemaLink(rootValue?: Record<string, unknown>) {
FILE: src/incremental/handlers/__tests__/graphql17Alpha9/stream.test.ts
function resolveOnNextTick (line 33) | function resolveOnNextTick(): Promise<void> {
function run (line 37) | function run(
function createSchemaLink (line 50) | function createSchemaLink(rootValue?: Record<string, unknown>) {
method friendList (line 776) | async *friendList() {
method friendList (line 879) | async *friendList() {
method friendList (line 967) | async *friendList() {
method friendList (line 1071) | async *friendList() {
method friendList (line 1123) | async *friendList() {
method friendList (line 1202) | async *friendList() {
method friendList (line 1503) | async *friendList() {
method nestedFriendList (line 1629) | async *nestedFriendList() {
method deeperNestedFriendList (line 1716) | async *deeperNestedFriendList() {
method friendList (line 1775) | async *friendList() {
method friendList (line 1858) | async *friendList() {
method nestedFriendList (line 1960) | async *nestedFriendList() {
method nestedFriendList (line 2062) | async *nestedFriendList() {
method nestedFriendList (line 2178) | async *nestedFriendList() {
method friendList (line 2275) | async *friendList() {
method friendList (line 2387) | async *friendList() {
method nestedFriendList (line 2857) | async *nestedFriendList() {
FILE: src/incremental/handlers/defer20220824.ts
type Defer20220824Result (line 18) | interface Defer20220824Result extends HKT {
type TypeOverrides (line 23) | interface TypeOverrides {
type InitialResult (line 27) | type InitialResult<TData = Record<string, unknown>> = {
type SubsequentResult (line 35) | type SubsequentResult<TData = Record<string, unknown>> = {
type IncrementalDeferResult (line 41) | type IncrementalDeferResult<TData = Record<string, unknown>> = {
type IncrementalStreamResult (line 49) | type IncrementalStreamResult<TData = Array<unknown>> = {
type IncrementalResult (line 57) | type IncrementalResult<TData = Record<string, unknown>> =
type Chunk (line 61) | type Chunk<TData extends Record<string, unknown>> =
class DeferRequest (line 66) | class DeferRequest<TData extends Record<string, unknown>>
method merge (line 81) | private merge(
method handle (line 98) | handle(
class Defer20220824Handler (line 170) | class Defer20220824Handler
method isIncrementalResult (line 173) | isIncrementalResult(
method extractErrors (line 181) | extractErrors(result: ApolloLink.Result<any>) {
method prepareRequest (line 205) | prepareRequest(request: ApolloLink.Request): ApolloLink.Request {
method startRequest (line 217) | startRequest<TData extends Record<string, unknown>>(_: {
function hasIncrementalChunks (line 225) | function hasIncrementalChunks(
FILE: src/incremental/handlers/graphql17Alpha9.ts
type GraphQL17Alpha9Result (line 27) | interface GraphQL17Alpha9Result extends HKT {
type TypeOverrides (line 33) | interface TypeOverrides {
type InitialResult (line 37) | type InitialResult<TData = Record<string, unknown>> = {
type SubsequentResult (line 45) | type SubsequentResult<TData = unknown> = {
type PendingResult (line 53) | interface PendingResult {
type CompletedResult (line 59) | interface CompletedResult {
type IncrementalDeferResult (line 64) | interface IncrementalDeferResult<TData = Record<string, unknown>> {
type IncrementalStreamResult (line 72) | interface IncrementalStreamResult<TData = ReadonlyArray<unknown>> {
type IncrementalResult (line 80) | type IncrementalResult<TData = unknown> =
type Chunk (line 84) | type Chunk<TData> = InitialResult<TData> | SubsequentResult<TData>;
class IncrementalRequest (line 87) | class IncrementalRequest<TData>
method handle (line 109) | handle(
method merge (line 263) | private merge(
class GraphQL17Alpha9Handler (line 287) | class GraphQL17Alpha9Handler
method isIncrementalResult (line 291) | isIncrementalResult(
method prepareRequest (line 300) | prepareRequest(request: ApolloLink.Request): ApolloLink.Request {
method extractErrors (line 317) | extractErrors(result: ApolloLink.Result<any>) {
method startRequest (line 349) | startRequest<TData>(_: { query: DocumentNode }) {
function hasIncrementalChunks (line 354) | function hasIncrementalChunks(
function hasCompletedChunks (line 360) | function hasCompletedChunks(
FILE: src/incremental/handlers/notImplemented.ts
type NotImplementedResult (line 9) | interface NotImplementedResult extends HKT {
type TypeOverrides (line 14) | interface TypeOverrides {
class NotImplementedHandler (line 19) | class NotImplementedHandler implements Incremental.Handler<never> {
method isIncrementalResult (line 20) | isIncrementalResult(_: any): _ is never {
method prepareRequest (line 23) | prepareRequest(request: ApolloLink.Request) {
method extractErrors (line 31) | extractErrors() {}
FILE: src/incremental/types.ts
type Path (line 11) | type Path = ReadonlyArray<string | number>;
type Handler (line 14) | interface Handler<
type IncrementalRequest (line 27) | interface IncrementalRequest<
type StreamFieldInfo (line 39) | interface StreamFieldInfo {
FILE: src/invariantErrorCodes.ts
type ErrorCodes (line 1) | interface ErrorCodes {
FILE: src/link/batch-http/BaseBatchHttpLink.ts
type ContextOptions (line 29) | interface ContextOptions extends BaseHttpLink.ContextOptions {}
type Options (line 39) | interface Options
class BaseBatchHttpLink (line 74) | class BaseBatchHttpLink extends ApolloLink {
method constructor (line 80) | constructor(options: BaseBatchHttpLink.Options = {}) {
method request (line 234) | public request(
FILE: src/link/batch-http/__tests__/batchHttpLink.ts
function trackGlobalAbortControllers (line 990) | function trackGlobalAbortControllers() {
FILE: src/link/batch-http/batchHttpLink.ts
type Options (line 11) | interface Options
type ContextOptions (line 24) | interface ContextOptions
class BatchHttpLink (line 53) | class BatchHttpLink extends ApolloLink {
method constructor (line 54) | constructor(options: BatchHttpLink.Options = {}) {
FILE: src/link/batch/__tests__/batchLink.ts
type MockedResponse (line 19) | interface MockedResponse {
function createOperation (line 29) | function createOperation(
function requestToKey (line 56) | function requestToKey(request: ApolloLink.Request): string {
function createMockBatchHandler (line 66) | function createMockBatchHandler(...mockedResponses: MockedResponse[]) {
FILE: src/link/batch/batchLink.ts
type Options (line 11) | interface Options {
type BatchHandler (line 56) | type BatchHandler = (
type Options (line 78) | interface Options extends Shared.Options {
class BatchLink (line 123) | class BatchLink extends ApolloLink {
method constructor (line 126) | constructor(options?: BatchLink.Options) {
method request (line 146) | public request(
FILE: src/link/batch/batching.ts
type BatchableRequest (line 8) | interface BatchableRequest {
type QueuedRequest (line 13) | type QueuedRequest = BatchableRequest & {
type RequestBatch (line 23) | type RequestBatch = Set<QueuedRequest> & {
class OperationBatcher (line 30) | class OperationBatcher {
method constructor (line 46) | constructor({
method enqueueRequest (line 66) | public enqueueRequest(
method consumeQueue (line 139) | public consumeQueue(
method scheduleQueueConsumption (line 216) | private scheduleQueueConsumption(key: string): void {
FILE: src/link/client-awareness/ClientAwarenessLink.ts
type ContextOptions (line 15) | interface ContextOptions {
type ClientAwarenessOptions (line 20) | interface ClientAwarenessOptions {
type EnhancedClientAwarenessOptions (line 48) | interface EnhancedClientAwarenessOptions {
type Options (line 60) | interface Options {
class ClientAwarenessLink (line 111) | class ClientAwarenessLink extends ApolloLink {
method constructor (line 112) | constructor(options: ClientAwarenessLink.Options = {}) {
FILE: src/link/context/index.ts
type ContextSetter (line 31) | type ContextSetter = (
type LegacyContextSetter (line 43) | type LegacyContextSetter = (
type SetContextOperation (line 55) | type SetContextOperation = Omit<
function setContext (line 73) | function setContext(setter: SetContextLink.LegacyContextSetter) {
class SetContextLink (line 97) | class SetContextLink extends ApolloLink {
method constructor (line 98) | constructor(setter: SetContextLink.ContextSetter) {
FILE: src/link/core/ApolloLink.ts
type ExecuteContext (line 29) | interface ExecuteContext {
type ForwardFunction (line 37) | type ForwardFunction = (
type Request (line 45) | interface Request {
type RequestHandler (line 72) | type RequestHandler = (
type AdditionalResultTypes (line 77) | type AdditionalResultTypes<
type Result (line 88) | type Result<
type Operation (line 99) | interface Operation {
type OperationContext (line 156) | interface OperationContext extends DefaultContext {}
class ApolloLink (line 226) | class ApolloLink {
method empty (line 236) | public static empty(): ApolloLink {
method from (line 261) | public static from(links: ApolloLink[]): ApolloLink {
method split (line 294) | public static split(
method execute (line 348) | public static execute(
method concat (line 381) | public static concat(...links: ApolloLink[]) {
method constructor (line 385) | constructor(request?: ApolloLink.RequestHandler) {
method split (line 421) | public split(
method concat (line 450) | public concat(...links: ApolloLink[]): ApolloLink {
method combine (line 458) | private combine(left: ApolloLink, right: ApolloLink) {
method request (line 474) | public request(
FILE: src/link/core/__tests__/ApolloLink.ts
class SetContextLink (line 13) | class SetContextLink extends ApolloLink {
method constructor (line 14) | constructor(
method request (line 22) | public request(
FILE: src/link/core/deprecated.ts
type GraphQLRequest (line 4) | type GraphQLRequest = ApolloLink.Request;
type Operation (line 7) | type Operation = ApolloLink.Operation;
type RequestHandler (line 10) | type RequestHandler = ApolloLink.RequestHandler;
type FetchResult (line 13) | type FetchResult<
FILE: src/link/core/types.ts
type ApolloPayloadResult (line 3) | interface ApolloPayloadResult<
FILE: src/link/error/index.ts
type ErrorHandler (line 30) | interface ErrorHandler {
type ErrorHandlerOptions (line 37) | interface ErrorHandlerOptions {
function onError (line 69) | function onError(errorHandler: ErrorLink.ErrorHandler) {
class ErrorLink (line 117) | class ErrorLink extends ApolloLink {
method constructor (line 118) | constructor(errorHandler: ErrorLink.ErrorHandler) {
FILE: src/link/http/BaseHttpLink.ts
function noop (line 28) | function noop() {}
type ContextOptions (line 40) | interface ContextOptions {
type HttpOptions (line 64) | interface HttpOptions {
type Options (line 94) | interface Options {
type Options (line 212) | interface Options extends Shared.Options {
type Body (line 224) | interface Body {
type Printer (line 231) | type Printer = (node: ASTNode, originalPrint: typeof print) => string;
type UriFunction (line 232) | type UriFunction = (operation: ApolloLink.Operation) => string;
class BaseHttpLink (line 263) | class BaseHttpLink extends ApolloLink {
method constructor (line 264) | constructor(options: BaseHttpLink.Options = {}) {
FILE: src/link/http/HttpLink.ts
type ContextOptions (line 16) | interface ContextOptions
type Options (line 29) | interface Options extends BaseHttpLink.Options, ClientAwarenessLink.Opti...
class HttpLink (line 54) | class HttpLink extends ApolloLink {
method constructor (line 55) | constructor(options: HttpLink.Options = {}) {
FILE: src/link/http/__tests__/HttpLink.ts
function convertBatchedBody (line 118) | function convertBatchedBody(body: BodyInit | null | undefined) {
function trackGlobalAbortControllers (line 1137) | function trackGlobalAbortControllers() {
method start (line 1430) | async start(controller) {
method start (line 1487) | async start(controller) {
method start (line 1852) | async start(controller) {
function pipeLinkToObservableStream (line 2481) | function pipeLinkToObservableStream(link: ApolloLink) {
FILE: src/link/http/__tests__/helpers.ts
function voidFetchDuringEachTest (line 1) | function voidFetchDuringEachTest() {
FILE: src/link/http/__tests__/responseIterator.ts
constant BOUNDARY (line 25) | const BOUNDARY = "gc0p4Jq0M2Yt08jU534c0p";
method start (line 90) | async start(controller) {
method start (line 126) | async start(controller) {
method transform (line 258) | transform(chunk, controller) {
method transform (line 294) | transform(chunk, controller) {
method transform (line 330) | transform(chunk, controller) {
method transform (line 370) | transform(chunk, controller) {
FILE: src/link/http/__tests__/responseIteratorNoAsyncIterator.ts
constant BOUNDARY (line 23) | const BOUNDARY = "gc0p4Jq0M2Yt08jU534c0p";
method start (line 151) | async start(controller) {
method start (line 187) | async start(controller) {
FILE: src/link/http/parseAndCheckHttpResponse.ts
function isApolloPayloadResult (line 18) | function isApolloPayloadResult(value: unknown): value is ApolloPayloadRe...
function readMultipartBody (line 110) | async function readMultipartBody<
function parseHeaders (line 136) | function parseHeaders(headerText: string): Record<string, string> {
function parseJsonEncoding (line 150) | function parseJsonEncoding(response: Response, bodyText: string) {
function parseGraphQLResponseJsonEncoding (line 165) | function parseGraphQLResponseJsonEncoding(
function parseResponse (line 176) | function parseResponse(response: Response, bodyText: string) {
function parseAndCheckHttpResponse (line 186) | function parseAndCheckHttpResponse(
FILE: src/link/http/rewriteURIForGET.ts
function rewriteURIForGET (line 5) | function rewriteURIForGET(chosenURI: string, body: BaseHttpLink.Body) {
FILE: src/link/http/selectHttpOptionsAndBody.ts
type HttpConfig (line 6) | interface HttpConfig {
function selectHttpOptionsAndBody (line 50) | function selectHttpOptionsAndBody(
function selectHttpOptionsAndBodyInternal (line 63) | function selectHttpOptionsAndBodyInternal(
function removeDuplicateHeaders (line 119) | function removeDuplicateHeaders(
FILE: src/link/persisted-queries/__tests__/persisted-queries.test.ts
function sha256 (line 76) | function sha256(data: string) {
function hash (line 216) | function hash(query: string) {
method sha256 (line 322) | sha256(data) {
method disable (line 547) | disable({ operation }) {
function hash (line 673) | function hash(query: string) {
FILE: src/link/persisted-queries/__tests__/react.test.tsx
function sha256 (line 22) | function sha256(data: string) {
FILE: src/link/persisted-queries/index.ts
constant VERSION (line 31) | const VERSION = 1;
type Options (line 80) | interface Options {
type ErrorMeta (line 119) | interface ErrorMeta {
type GenerateHashFunction (line 138) | type GenerateHashFunction = (
type SHA256Function (line 143) | type SHA256Function = (
type SHA256Options (line 153) | interface SHA256Options extends Base.Options {
type GenerateHashOptions (line 169) | interface GenerateHashOptions extends Base.Options {
type Options (line 185) | type Options =
type RetryFunctionOptions (line 193) | interface RetryFunctionOptions {
type DisableFunctionOptions (line 219) | interface DisableFunctionOptions
function processErrors (line 223) | function processErrors(
function operationDefinesMutation (line 257) | function operationDefinesMutation(operation: ApolloLink.Operation) {
class PersistedQueryLink (line 286) | class PersistedQueryLink extends ApolloLink {
method constructor (line 287) | constructor(options: PersistedQueryLink.Options) {
FILE: src/link/remove-typename/__tests__/removeTypenameFromVariables.ts
type PartialOperation (line 13) | type PartialOperation = Partial<Pick<ApolloLink.Operation, "variables">> &
function execute (line 19) | async function execute(link: ApolloLink, operation: PartialOperation) {
FILE: src/link/remove-typename/removeTypenameFromVariables.ts
constant KEEP (line 41) | const KEEP = "__KEEP";
type KeepTypenameConfig (line 77) | interface KeepTypenameConfig {
type Options (line 86) | interface Options {
function removeTypenameFromVariables (line 126) | function removeTypenameFromVariables(
class RemoveTypenameFromVariablesLink (line 153) | class RemoveTypenameFromVariablesLink extends ApolloLink {
method constructor (line 154) | constructor(options: RemoveTypenameFromVariablesLink.Options = {}) {
method maybeStripTypenameUsingConfig (line 184) | private maybeStripTypenameUsingConfig(
method maybeStripTypename (line 207) | private maybeStripTypename(
method VariableDefinition (line 248) | VariableDefinition(node) {
type JSONPrimitive (line 265) | type JSONPrimitive = string | number | null | boolean;
type JSONValue (line 266) | type JSONValue = JSONPrimitive | JSONValue[] | { [key: string]: JSONValu...
function unwrapType (line 268) | function unwrapType(node: TypeNode): string {
FILE: src/link/retry/__tests__/delayFunction.ts
type SimpleDelayFunction (line 8) | interface SimpleDelayFunction {
function delayRange (line 12) | function delayRange(delayFunction: SimpleDelayFunction, count: number) {
FILE: src/link/retry/__tests__/retryLink.ts
method subscribe (line 81) | subscribe(observer: any) {
FILE: src/link/retry/delayFunction.ts
function buildDelayFunction (line 3) | function buildDelayFunction(
FILE: src/link/retry/retryFunction.ts
function buildRetryFunction (line 3) | function buildRetryFunction(
FILE: src/link/retry/retryLink.ts
type DelayFunction (line 48) | type DelayFunction = (
type DelayOptions (line 57) | interface DelayOptions {
type AttemptsFunction (line 93) | type AttemptsFunction = (
type AttemptsOptions (line 102) | interface AttemptsOptions {
type Options (line 132) | interface Options {
class RetryableOperation (line 145) | class RetryableOperation {
method constructor (line 150) | constructor(
method cancel (line 163) | public cancel() {
method try (line 172) | private try() {
method scheduleRetry (line 213) | private scheduleRetry(delay: number) {
class RetryLink (line 250) | class RetryLink extends ApolloLink {
method constructor (line 254) | constructor(options?: RetryLink.Options) {
method request (line 263) | public request(
FILE: src/link/schema/__tests__/schemaLink.ts
method sampleQuery (line 60) | sampleQuery() {
FILE: src/link/schema/index.ts
type ResolverContext (line 47) | type ResolverContext = Record<string, any>;
type ResolverContextFunction (line 50) | type ResolverContextFunction = (
type Options (line 57) | interface Options {
class SchemaLink (line 136) | class SchemaLink extends ApolloLink {
method constructor (line 142) | constructor(options: SchemaLink.Options) {
method request (line 150) | public request(
FILE: src/link/subscriptions/__tests__/graphqlWsLink.ts
function mockClient (line 38) | function mockClient(subscribe: Client["subscribe"]): Client {
function observableToArray (line 49) | async function observableToArray<T>(o: Observable<T>): Promise<T[]> {
type SubscribeFn (line 191) | type SubscribeFn = Client["subscribe"];
FILE: src/link/subscriptions/index.ts
function isLikeCloseEvent (line 41) | function isLikeCloseEvent(val: unknown): val is CloseEvent {
function isLikeErrorEvent (line 46) | function isLikeErrorEvent(err: unknown): err is Event {
class GraphQLWsLink (line 73) | class GraphQLWsLink extends ApolloLink {
method constructor (line 74) | constructor(public readonly client: Client) {
method request (line 78) | public request(
FILE: src/link/utils/createOperation.ts
function createOperation (line 7) | function createOperation(
FILE: src/link/utils/filterOperationVariables.ts
function filterOperationVariables (line 4) | function filterOperationVariables(
FILE: src/link/ws/index.ts
type Configuration (line 20) | interface Configuration {
class WebSocketLink (line 90) | class WebSocketLink extends ApolloLink {
method constructor (line 93) | constructor(
method request (line 115) | public request(
FILE: src/local-state/LocalState.ts
type ExecContext (line 53) | interface ExecContext {
type ExportedVariable (line 73) | interface ExportedVariable {
type TraverseCacheEntry (line 97) | interface TraverseCacheEntry {
type InferContextValueFromResolvers (line 119) | type InferContextValueFromResolvers<TResolvers> =
type MaybeRequireContextFunction (line 130) | type MaybeRequireContextFunction<TContext> =
type Options (line 145) | type Options<
type RootValueFunctionContext (line 157) | interface RootValueFunctionContext {
type ContextFunction (line 165) | type ContextFunction<TContext> = (
type ContextFunctionOptions (line 169) | interface ContextFunctionOptions {
type RootValueFunction (line 177) | type RootValueFunction<TRootValue> = (
type Resolvers (line 200) | interface Resolvers<TContext = any> {
type Resolver (line 229) | type Resolver<
type Path (line 249) | type Path = Array<string | number>;
class LocalState (line 281) | class LocalState<
method constructor (line 293) | constructor(
method addResolvers (line 326) | public addResolvers(resolvers: TResolvers) {
method execute (line 330) | public async execute<
method getExportedVariables (line 436) | public async getExportedVariables<
method resolveSelectionSet (line 508) | private async resolveSelectionSet(
method resolveServerField (line 625) | private resolveServerField(
method resolveClientField (line 673) | private async resolveClientField(
method addError (line 892) | private addError(
method getResolver (line 908) | private getResolver(
method resolveSubSelectedArray (line 915) | private resolveSubSelectedArray(
method collectQueryDetail (line 956) | private collectQueryDetail(document: DocumentNode): TraverseCacheEntry...
function inferRootTypename (line 1093) | function inferRootTypename({ operation }: OperationDefinitionNode) {
function isGraphQLError (line 1098) | function isGraphQLError(error: ErrorLike): error is GraphQLError {
function addExtension (line 1111) | function addExtension(error: GraphQLFormattedError, meta: Record<string,...
function getExportedVariableName (line 1121) | function getExportedVariableName(directive: DirectiveNode) {
function validateCacheImplementation (line 1131) | function validateCacheImplementation(cache: ApolloCache) {
function getCacheResultAtPath (line 1138) | function getCacheResultAtPath(
function isForcedResolver (line 1150) | function isForcedResolver(field: FieldNode) {
function toQueryOperation (line 1170) | function toQueryOperation(document: DocumentNode): DocumentNode {
FILE: src/local-state/__tests__/LocalState/async.test.ts
method isLoggedIn (line 22) | async isLoggedIn() {
function randomDelay (line 64) | async function randomDelay(range: number) {
function uuid (line 68) | function uuid() {
function times (line 74) | function times<T>(n: number, thunk: () => T): T[] {
method developer (line 88) | async developer(_, { id }) {
method tickets (line 99) | async tickets(developer) {
method comments (line 112) | async comments(ticket) {
method isLoggedIn (line 189) | async isLoggedIn() {
method sessionCount (line 192) | sessionCount() {
FILE: src/local-state/__tests__/LocalState/base.test.ts
method userData (line 451) | userData() {
method fullName (line 460) | fullName(data) {
method fullName (line 517) | fullName(member) {
FILE: src/local-state/__tests__/LocalState/cache.test.ts
method start (line 28) | start(_data, _args, { client }) {
method start (line 73) | start(_, __, { client }) {
method start (line 143) | start(_, __, { client }) {
method read (line 280) | read() {
method read (line 321) | read() {
method read (line 439) | read() {
method read (line 560) | read() {
method read (line 629) | read() {
FILE: src/local-state/__tests__/LocalState/fixtures/base-types.ts
type Query (line 3) | type Query = {
type User (line 7) | type User = {
FILE: src/local-state/__tests__/LocalState/fixtures/context-value.ts
type ContextValue (line 3) | interface ContextValue extends DefaultContext {
FILE: src/local-state/__tests__/LocalState/fixtures/local-resolvers-without-context-value.ts
type Maybe (line 6) | type Maybe<T> = T | null;
type InputMaybe (line 7) | type InputMaybe<T> = Maybe<T>;
type Exact (line 8) | type Exact<T extends { [key: string]: unknown }> = {
type MakeOptional (line 11) | type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
type MakeMaybe (line 14) | type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
type MakeEmpty (line 17) | type MakeEmpty<
type Incremental (line 21) | type Incremental<T> =
type RequireFields (line 26) | type RequireFields<T, K extends keyof T> = Omit<T, K> & {
type Scalars (line 30) | type Scalars = {
type Food (line 38) | type Food = {
type FoodCategoriesArgs (line 44) | type FoodCategoriesArgs = {
type FoodCategory (line 49) | enum FoodCategory {
type Query (line 53) | type Query = {
type User (line 58) | type User = {
type ResolversTypes (line 65) | type ResolversTypes = {
type ResolversParentTypes (line 77) | type ResolversParentTypes = {
type FoodResolvers (line 87) | type FoodResolvers = {
type QueryResolvers (line 101) | type QueryResolvers = {
type UserResolvers (line 109) | type UserResolvers = {
type Resolvers (line 122) | type Resolvers = {
FILE: src/local-state/__tests__/LocalState/fixtures/local-resolvers.ts
type Maybe (line 6) | type Maybe<T> = T | null;
type InputMaybe (line 7) | type InputMaybe<T> = Maybe<T>;
type Exact (line 8) | type Exact<T extends { [key: string]: unknown }> = {
type MakeOptional (line 11) | type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
type MakeMaybe (line 14) | type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
type MakeEmpty (line 17) | type MakeEmpty<
type Incremental (line 21) | type Incremental<T> =
type RequireFields (line 26) | type RequireFields<T, K extends keyof T> = Omit<T, K> & {
type Scalars (line 30) | type Scalars = {
type Food (line 38) | type Food = {
type FoodCategoriesArgs (line 44) | type FoodCategoriesArgs = {
type FoodCategory (line 49) | enum FoodCategory {
type Query (line 53) | type Query = {
type User (line 58) | type User = {
type ResolversTypes (line 65) | type ResolversTypes = {
type ResolversParentTypes (line 77) | type ResolversParentTypes = {
type FoodResolvers (line 87) | type FoodResolvers = {
type QueryResolvers (line 101) | type QueryResolvers = {
type UserResolvers (line 109) | type UserResolvers = {
type Resolvers (line 122) | type Resolvers = {
FILE: src/local-state/__tests__/LocalState/forcedResolvers.test.ts
method isLoggedIn (line 53) | isLoggedIn() {
method name (line 97) | name() {
method isLoggedIn (line 101) | isLoggedIn() {
method user (line 157) | user() {
method isLoggedIn (line 163) | isLoggedIn() {
FILE: src/local-state/__tests__/LocalState/fragments.test.ts
class TestCache (line 173) | class TestCache extends ApolloCache {}
FILE: src/local-state/__tests__/LocalState/testUtils.ts
constant WARNINGS (line 8) | const WARNINGS = {
FILE: src/local-state/__tests__/LocalState/types.test.ts
type SetRequired (line 7) | type SetRequired<T, Keys extends keyof T> = { [K in Keys]-?: T[K] } & Omit<
type Food (line 14) | interface Food {
type Resolvers (line 60) | type Resolvers =
type Food (line 62) | type Food =
type RequiredRootResolver (line 68) | type RequiredRootResolver = SetRequired<Resolvers, "Query">;
type Resolvers (line 239) | type Resolvers = import("./fixtures/local-resolvers.js").Resolvers;
FILE: src/masking/GraphQLCodegenDataMasking.ts
type TypeOverrides (line 10) | interface TypeOverrides {
type FragmentType (line 16) | interface FragmentType extends HKT {
type MaybeMasked (line 21) | interface MaybeMasked extends HKT {
type Unmasked (line 26) | interface Unmasked extends HKT {
type FragmentType (line 32) | type FragmentType<TData> =
type MaybeMasked (line 46) | type MaybeMasked<TData> = TData;
type Unmasked (line 51) | type Unmasked<TData> =
FILE: src/masking/PreserveTypes.ts
type TypeOverrides (line 4) | interface TypeOverrides {
type FragmentType (line 10) | interface FragmentType extends HKT {
type MaybeMasked (line 15) | interface MaybeMasked extends HKT {
type Unmasked (line 20) | interface Unmasked extends HKT {
type FragmentType (line 26) | type FragmentType<_TData> = never;
type MaybeMasked (line 27) | type MaybeMasked<TData> = TData;
type Unmasked (line 28) | type Unmasked<TData> = TData;
FILE: src/masking/__benches__/types.bench.ts
function test (line 19) | function test(name: string, fn: (name: string) => void) {
type UnrelatedType (line 23) | type UnrelatedType = {
type _TypeCacheWarmup (line 33) | type _TypeCacheWarmup = Unmasked<UnrelatedType> | MaybeMasked<UnrelatedT...
type UserFieldsFragment (line 36) | type UserFieldsFragment = {
type NameFieldsFragment (line 47) | type NameFieldsFragment = {
type JobFieldsFragment (line 53) | type JobFieldsFragment = {
type CareerFieldsFragment (line 60) | type CareerFieldsFragment = {
type Source (line 65) | type Source = UserFieldsFragment;
type UserFieldsFragment (line 85) | type UserFieldsFragment = {
type NameFieldsFragment (line 102) | type NameFieldsFragment = {
type JobFieldsFragment (line 108) | type JobFieldsFragment = {
type CareerFieldsFragment (line 115) | type CareerFieldsFragment = {
type Source (line 120) | type Source = UserFieldsFragment;
type UserFieldsFragment (line 145) | type UserFieldsFragment = {
type NameFieldsFragment (line 170) | type NameFieldsFragment = {
type JobFieldsFragment (line 176) | type JobFieldsFragment = {
type CareerFieldsFragment (line 183) | type CareerFieldsFragment = {
type Source (line 188) | type Source = UserFieldsFragment;
type UserFieldsFragment (line 220) | type UserFieldsFragment = {
type NameFieldsFragment (line 230) | type NameFieldsFragment = {
type Source (line 236) | type Source = DeepPartial<UserFieldsFragment>;
type Source (line 340) | type Source = {
type ArtistFragment (line 358) | type ArtistFragment = {
type NestedTrackFragment (line 365) | type NestedTrackFragment = {
type Source (line 404) | type Source = {
type PersonFragment (line 419) | type PersonFragment = {
type AnimatronicFragment (line 424) | type AnimatronicFragment = {
type CartoonCharacterFragment (line 430) | type CartoonCharacterFragment = {
type Source (line 476) | interface Source {
type Source (line 493) | interface Source {
type MetadataItem (line 511) | interface MetadataItem {
type Source (line 515) | interface Source {
type Source (line 532) | interface Source {
type Source (line 550) | type Source = {
type StructuredMetadata (line 561) | interface StructuredMetadata {
type FooFragment (line 566) | type FooFragment = {
type Source (line 592) | type Source = import("graphql").IntrospectionQuery;
function withGenericResult (line 606) | function withGenericResult<T extends { [key: string]: string }>(
function withGenericDocument (line 619) | function withGenericDocument<T extends TypedDocumentNode>(arg: T) {
type Branded (line 637) | type Branded<T, Name extends string> = T & { __branded?: Name };
type UUID (line 638) | type UUID = Branded<string, "UUID">;
type Source (line 639) | type Source = {
type FooFragment (line 648) | type FooFragment = {
type UserFieldsFragment (line 670) | type UserFieldsFragment = {
type NameFieldsFragment (line 680) | type NameFieldsFragment = {
type Source (line 686) | type Source = UserFieldsFragment;
FILE: src/masking/__tests__/utils.test.ts
function getFragmentSpreadNode (line 124) | function getFragmentSpreadNode(document: DocumentNode): FragmentSpreadNo...
FILE: src/masking/internal/types.ts
type UnwrapFragmentRefs (line 8) | type UnwrapFragmentRefs<TData> =
type CombineIntersection (line 51) | type CombineIntersection<T> =
type CombineByTypeName (line 70) | type CombineByTypeName<T extends { __typename?: string }> = {
type ExtractByMatchingTypeNames (line 120) | type ExtractByMatchingTypeNames<
type MergeUnions (line 132) | type MergeUnions<TUnion> = MergeUnionsAcc<
type DistributedRequiredExclude (line 138) | type DistributedRequiredExclude<T, U> =
type MergeUnionsAcc (line 147) | type MergeUnionsAcc<TUnion, Curr, Merged> =
type unionToIntersection (line 154) | type unionToIntersection<T> =
type takeOneFromUnion (line 161) | type takeOneFromUnion<T> =
type MergeObjects (line 168) | type MergeObjects<T, U> = Prettify<
type RemoveFragmentName (line 186) | type RemoveFragmentName<T> =
type Exact (line 189) | type Exact<in out T> = (x: T) => T;
type ContainsFragmentsRefs (line 190) | type ContainsFragmentsRefs<TData, Seen = never> = true extends (
FILE: src/masking/maskDefinition.ts
type MaskingContext (line 15) | interface MaskingContext {
function maskDefinition (line 24) | function maskDefinition(
function getMutableTarget (line 39) | function getMutableTarget(
function maskSelectionSet (line 52) | function maskSelectionSet(
function getAccessorWarningDescriptor (line 208) | function getAccessorWarningDescriptor(
FILE: src/masking/maskFragment.ts
function maskFragment (line 20) | function maskFragment<TData = unknown>(
FILE: src/masking/maskOperation.ts
function maskOperation (line 17) | function maskOperation<TData = unknown>(
FILE: src/masking/types.ts
type FragmentType (line 11) | type FragmentType<TFragmentDataOrTypedDocumentNode> =
type Unmasked (line 24) | type Unmasked<TData> = ApplyHKTImplementationWithDefault<
type MaybeMasked (line 35) | type MaybeMasked<TData> = ApplyHKTImplementationWithDefault<
FILE: src/masking/utils.ts
function getFragmentMaskMode (line 13) | function getFragmentMaskMode(
FILE: src/react/context/ApolloContext.ts
type ApolloContextValue (line 11) | interface ApolloContextValue {
function getApolloContext (line 22) | function getApolloContext(): ReactTypes.Context<ApolloContextValue> {
FILE: src/react/context/ApolloProvider.tsx
type Props (line 10) | interface Props {
FILE: src/react/hooks/__tests__/useApolloClient.test.tsx
function App (line 17) | function App() {
function App (line 30) | function App() {
FILE: src/react/hooks/__tests__/useBackgroundQuery.test.tsx
function createDefaultTrackedComponents (line 79) | function createDefaultTrackedComponents<
function createTrackedErrorComponents (line 113) | function createTrackedErrorComponents<Snapshot extends { error: Error | ...
function createErrorProfiler (line 134) | function createErrorProfiler<TData = unknown>() {
function createDefaultProfiler (line 143) | function createDefaultProfiler<TData = unknown>() {
function App (line 159) | function App() {
function App (line 204) | function App() {
function App (line 328) | function App() {
function App (line 407) | function App() {
function App (line 516) | function App() {
function App (line 613) | function App() {
function App (line 672) | function App() {
function App (line 709) | function App({ id }: { id: string }) {
function App (line 754) | function App() {
function App (line 788) | function App() {
function App (line 843) | function App() {
function App (line 901) | function App() {
function App (line 955) | function App() {
function App (line 1022) | function App() {
function App (line 1083) | function App() {
function App (line 1139) | function App() {
function App (line 1199) | function App() {
type Variables (line 1238) | type Variables = {
type Data (line 1242) | interface Data {
function App (line 1296) | function App() {
function App (line 1406) | function App() {
function App (line 1482) | function App({ id }: { id: string }) {
function App (line 1550) | function App() {
function App (line 1578) | function App() {
function App (line 1607) | function App() {
function App (line 1661) | function App() {
function App (line 1715) | function App() {
function App (line 1774) | function App() {
function App (line 1858) | function App() {
function App (line 1948) | function App() {
function App (line 2038) | function App() {
function App (line 2129) | function App() {
function App (line 2198) | function App() {
function App (line 2255) | function App() {
function App (line 2336) | function App() {
function App (line 2427) | function App() {
type Data (line 2489) | interface Data {
function App (line 2517) | function App() {
type Data (line 2574) | interface Data {
method merge (line 2612) | merge(existing: number[] | undefined, incoming: number[]) {
function App (line 2631) | function App() {
type PartialData (line 2737) | interface PartialData {
function App (line 2800) | function App() {
function App (line 2904) | function App() {
function App (line 3046) | function App() {
function App (line 3188) | function App() {
function App (line 3257) | function App({ id }: { id: string }) {
function App (line 3359) | function App() {
function App (line 3428) | function App() {
function App (line 3530) | function App() {
function App (line 3599) | function App({ id }: { id: string }) {
function App (line 3691) | function App() {
type UserFieldsFragment (line 3745) | type UserFieldsFragment = {
type Query (line 3749) | interface Query {
function App (line 3797) | function App() {
type UserFieldsFragment (line 3835) | type UserFieldsFragment = {
type Query (line 3839) | interface Query {
function App (line 3888) | function App() {
type UserFieldsFragment (line 3923) | type UserFieldsFragment = {
type Query (line 3927) | interface Query {
function App (line 3975) | function App() {
type UserFieldsFragment (line 4010) | type UserFieldsFragment = {
type Query (line 4014) | interface Query {
function App (line 4062) | function App() {
type UserFieldsFragment (line 4129) | type UserFieldsFragment = {
type Query (line 4133) | interface Query {
function App (line 4181) | function App() {
type UserFieldsFragment (line 4244) | type UserFieldsFragment = {
type Query (line 4248) | interface Query {
function App (line 4308) | function App() {
type UserFieldsFragment (line 4341) | type UserFieldsFragment = {
type Query (line 4345) | interface Query {
function App (line 4406) | function App() {
type UserFieldsFragment (line 4458) | type UserFieldsFragment = {
type Query (line 4463) | interface Query {
function App (line 4527) | function App() {
type UserFieldsFragment (line 4576) | type UserFieldsFragment = {
type Query (line 4580) | interface Query {
function App (line 4630) | function App() {
function App (line 4700) | function App() {
function App (line 4780) | function App() {
function App (line 4889) | function App() {
function App (line 5004) | function App() {
function App (line 5094) | function App() {
function App (line 5194) | function App() {
type VariablesCaseData (line 5278) | type VariablesCaseData = {
function App (line 5313) | function App() {
type Variables (line 5404) | type Variables = {
type Data (line 5408) | interface Data {
function ErrorFallback (line 5449) | function ErrorFallback({ error, resetErrorBoundary }: FallbackProps) {
function App (line 5456) | function App() {
function Todo (line 5474) | function Todo({ queryRef }: { queryRef: QueryRef<Data> }) {
type Variables (line 5540) | type Variables = {
type Data (line 5544) | interface Data {
function ErrorFallback (line 5585) | function ErrorFallback({ error, resetErrorBoundary }: FallbackProps) {
function App (line 5592) | function App() {
function Todo (line 5610) | function Todo({ queryRef }: { queryRef: QueryRef<Data> }) {
type Variables (line 5664) | type Variables = {
type Data (line 5668) | interface Data {
function App (line 5715) | function App() {
type QueryData (line 5820) | interface QueryData {
method merge (line 5844) | merge(existing: number[] | undefined, incoming: number[]) {
function App (line 5863) | function App() {
type QueryData (line 5940) | interface QueryData {
method merge (line 5964) | merge(existing: number[] | undefined, incoming: number[]) {
function App (line 5983) | function App() {
function App (line 6064) | function App() {
function App (line 6141) | function App() {
function App (line 6241) | function App() {
type Variables (line 6315) | type Variables = {
type Todo (line 6319) | interface Todo {
type Data (line 6326) | interface Data {
function App (line 6399) | function App() {
type Variables (line 6530) | type Variables = {
type Todo (line 6534) | interface Todo {
type Data (line 6540) | interface Data {
function App (line 6618) | function App() {
type SubscriptionData (line 6739) | interface SubscriptionData {
type UpdateQueryFn (line 6743) | type UpdateQueryFn = NonNullable<
function App (line 6793) | function App() {
type CharacterFragment (line 9362) | type CharacterFragment = {
type Subscription (line 9367) | type Subscription = {
type UnmaskedSubscription (line 9374) | type UnmaskedSubscription = {
FILE: src/react/hooks/__tests__/useBackgroundQuery/defer20220824.test.tsx
function renderSuspenseHook (line 27) | async function renderSuspenseHook<
type Data (line 92) | interface Data {
type QueryData (line 220) | interface QueryData {
FILE: src/react/hooks/__tests__/useBackgroundQuery/deferGraphQL17Alpha9.test.tsx
function renderSuspenseHook (line 27) | async function renderSuspenseHook<
type Data (line 92) | interface Data {
type QueryData (line 222) | interface QueryData {
FILE: src/react/hooks/__tests__/useBackgroundQuery/streamDefer20220824.test.tsx
function renderSuspenseHook (line 31) | async function renderSuspenseHook<
function createLink (line 95) | function createLink(rootValue?: unknown) {
type Data (line 115) | interface Data {
type QueryData (line 263) | interface QueryData {
FILE: src/react/hooks/__tests__/useBackgroundQuery/streamGraphQL17Alpha9.test.tsx
function renderSuspenseHook (line 31) | async function renderSuspenseHook<
function createLink (line 95) | function createLink(rootValue?: unknown) {
type Data (line 115) | interface Data {
type QueryData (line 263) | interface QueryData {
FILE: src/react/hooks/__tests__/useBackgroundQuery/testUtils.tsx
function renderUseBackgroundQuery (line 13) | async function renderUseBackgroundQuery<
FILE: src/react/hooks/__tests__/useFragment.test.tsx
type Item (line 52) | type Item = {
type QueryData (line 75) | interface QueryData {
type QueryDataWithExtra (line 80) | interface QueryDataWithExtra extends QueryData {
method text (line 89) | text(existing, { readField }) {
function List (line 118) | function List() {
function Item (line 127) | function Item(props: { id: number }) {
function getItemTexts (line 146) | function getItemTexts() {
method list (line 194) | list(list: readonly Reference[], { readField }) {
function Component (line 381) | function Component() {
function Component (line 415) | function Component() {
function Component (line 433) | function Component() {
function List (line 525) | function List() {
function Item (line 537) | function Item({ item }: { item: Item }) {
function getItemTexts (line 596) | function getItemTexts() {
function appendLyToText (line 615) | function appendLyToText(id: number) {
method text (line 830) | text(existing, { readField }) {
function List (line 863) | function List() {
function Item (line 880) | function Item(props: { id: number }) {
function getItemTexts (line 898) | function getItemTexts() {
method list (line 946) | list(list: readonly Reference[], { readField }) {
method list (line 1080) | list(items: Reference[] | undefined, { canRead }) {
function checkHistory (line 1134) | function checkHistory(expectedResultCount: number) {
method update (line 1234) | update(cache) {
method text (line 1312) | text(existing, { readField }) {
function List (line 1357) | function List() {
function Item (line 1391) | function Item({ id }: { id: number }) {
function getItemTexts (line 1408) | function getItemTexts() {
type User (line 1450) | type User = { __typename: "User"; id: number; name: string };
type User (line 1509) | type User = { __typename: "User"; id: number; name: string };
type Post (line 1571) | type Post = {
type Post (line 1640) | type Post = {
type Fragment (line 1722) | interface Fragment {
type Fragment (line 1765) | interface Fragment {
type Fragment (line 1803) | interface Fragment {
type Post (line 2003) | type Post = {
type Post (line 2072) | type Post = {
type ParentFragment (line 2153) | type ParentFragment = {
type ChildFragment (line 2159) | type ChildFragment = {
function Parent (line 2205) | function Parent() {
function Child (line 2218) | function Child({ parent }: { parent: ParentFragment }) {
function Component (line 2329) | function Component() {
function Parent (line 2397) | function Parent() {
function Child (line 2415) | function Child({ id }: { id: number }) {
function Parent (line 2494) | function Parent() {
function Child (line 2517) | function Child() {
method onRender (line 2525) | onRender() {
FILE: src/react/hooks/__tests__/useFragment/arrays.test.tsx
type Item (line 12) | type Item = {
type Item (line 65) | type Item = {
type Item (line 103) | type Item = {
type Item (line 144) | type Item = {
type Item (line 193) | type Item = {
type Item (line 233) | type Item = {
type Item (line 280) | type Item = {
type Item (line 336) | type Item = {
type Item (line 445) | type Item = {
FILE: src/react/hooks/__tests__/useLazyQuery.test.tsx
type Data (line 2343) | interface Data {
type Variables (line 2347) | interface Variables {
type Data (line 2430) | interface Data {
type Variables (line 2434) | interface Variables {
type Data (line 2609) | interface Data {
type Variables (line 2613) | interface Variables {
type Data (line 2665) | interface Data {
type Variables (line 2669) | interface Variables {
type Data (line 2754) | interface Data {
type Variables (line 2758) | interface Variables {
type Data (line 3017) | interface Data {
type Variables (line 3021) | interface Variables {
type UserFieldsFragment (line 3391) | type UserFieldsFragment = {
type Query (line 3396) | interface Query {
type UserFieldsFragment (line 3503) | type UserFieldsFragment = {
type Query (line 3508) | interface Query {
type UserFieldsFragment (line 3620) | type UserFieldsFragment = {
type Query (line 3625) | interface Query {
type UserFieldsFragment (line 3736) | type UserFieldsFragment = {
type Query (line 3741) | interface Query {
type UserFieldsFragment (line 3872) | type UserFieldsFragment = {
type Query (line 3877) | interface Query {
function App (line 4180) | function App() {
function App (line 4208) | function App() {
method merge (line 5281) | merge(existing: number[] | undefined, incoming: number[]) {
type UserFieldsFragment (line 6397) | type UserFieldsFragment = {
type Query (line 6402) | interface Query {
type UnmaskedQuery (line 6410) | interface UnmaskedQuery {
type Subscription (line 6419) | interface Subscription {
type UnmaskedSubscription (line 6427) | interface UnmaskedSubscription {
method updateQuery (line 6450) | updateQuery(queryData, { subscriptionData, complete, previousData }) {
type UserFieldsFragment (line 6510) | type UserFieldsFragment = {
type Query (line 6515) | interface Query {
type UnmaskedQuery (line 6523) | interface UnmaskedQuery {
type Subscription (line 6532) | interface Subscription {
type UnmaskedSubscription (line 6540) | interface UnmaskedSubscription {
method updateQuery (line 6563) | updateQuery(queryData, { subscriptionData, complete, previousData }) {
FILE: src/react/hooks/__tests__/useLoadableQuery.test.tsx
constant IS_REACT_19 (line 69) | const IS_REACT_19 = React.version.startsWith("19");
type SimpleQueryData (line 75) | interface SimpleQueryData {
function useSimpleQueryCase (line 79) | function useSimpleQueryCase() {
type VariablesCaseData (line 97) | interface VariablesCaseData {
type VariablesCaseVariables (line 104) | interface VariablesCaseVariables {
function useVariablesQueryCase (line 108) | function useVariablesQueryCase() {
type PaginatedQueryData (line 131) | interface PaginatedQueryData {
type PaginatedQueryVariables (line 138) | interface PaginatedQueryVariables {
function usePaginatedQueryCase (line 143) | function usePaginatedQueryCase() {
function createDefaultProfiler (line 175) | function createDefaultProfiler<TData>() {
function createDefaultProfiledComponents (line 185) | function createDefaultProfiledComponents<
function renderWithMocks (line 240) | async function renderWithMocks(
function renderWithClient (line 256) | async function renderWithClient(
function App (line 282) | function App() {
function App (line 341) | function App() {
function App (line 405) | function App() {
function App (line 542) | function App() {
function App (line 631) | function App() {
function App (line 825) | function App() {
function App (line 916) | function App() {
type QueryData (line 957) | interface QueryData {
function App (line 986) | function App() {
type QueryData (line 1027) | type QueryData = { hello: string };
function App (line 1052) | function App() {
function App (line 1133) | function App() {
function App (line 1206) | function App() {
function App (line 1278) | function App() {
function App (line 1349) | function App() {
type Variables (line 1401) | type Variables = {
type Data (line 1405) | interface Data {
function SuspenseFallback (line 1447) | function SuspenseFallback() {
function App (line 1451) | function App() {
function Todo (line 1466) | function Todo({
function App (line 1550) | function App() {
function App (line 1633) | function App() {
type Data (line 1703) | interface Data {
function App (line 1736) | function App() {
type Data (line 1799) | interface Data {
method merge (line 1835) | merge(existing: number[] | undefined, incoming: number[]) {
function App (line 1855) | function App() {
type Data (line 1959) | interface Data {
type PartialData (line 1967) | interface PartialData {
function App (line 2039) | function App() {
type Data (line 2131) | interface Data {
function App (line 2188) | function App() {
function App (line 2301) | function App() {
function App (line 2393) | function App() {
function App (line 2480) | function App() {
function App (line 2596) | function App() {
function App (line 2679) | function App() {
function App (line 2769) | function App() {
type VariablesCaseData (line 2835) | type VariablesCaseData = {
function App (line 2882) | function App() {
type Variables (line 2951) | type Variables = {
type Data (line 2955) | interface Data {
function SuspenseFallback (line 2990) | function SuspenseFallback() {
function App (line 2994) | function App() {
function Todo (line 3010) | function Todo({
function App (line 3101) | function App() {
function App (line 3185) | function App() {
function App (line 3288) | function App() {
type Variables (line 3365) | type Variables = {
type Todo (line 3369) | interface Todo {
type Data (line 3375) | interface Data {
function SuspenseFallback (line 3437) | function SuspenseFallback() {
function App (line 3441) | function App() {
function Todo (line 3454) | function Todo({
type QueryData (line 3540) | interface QueryData {
method merge (line 3564) | merge(existing: number[] | undefined, incoming: number[]) {
function App (line 3584) | function App() {
type QueryData (line 3663) | interface QueryData {
method merge (line 3687) | merge(existing: number[] | undefined, incoming: number[]) {
function App (line 3707) | function App() {
type Data (line 3770) | interface Data {
function App (line 3815) | function App() {
function App (line 3898) | function App() {
type Data (line 3981) | interface Data {
function App (line 4024) | function App() {
type Data (line 4078) | interface Data {
function App (line 4121) | function App() {
type Data (line 4199) | interface Data {
function App (line 4242) | function App() {
function App (line 4321) | function App() {
function App (line 4403) | function App() {
function App (line 4434) | function App() {
function App (line 4466) | function App() {
type SubscriptionData (line 4482) | interface SubscriptionData {
type UpdateQueryFn (line 4486) | type UpdateQueryFn = NonNullable<
function App (line 4537) | function App() {
type SubscriptionData (line 4629) | interface SubscriptionData {
function App (line 4676) | function App() {
FILE: src/react/hooks/__tests__/useLoadableQuery/defer20220824.test.tsx
function renderHook (line 28) | async function renderHook<
type Data (line 114) | interface Data {
type QueryData (line 253) | interface QueryData {
FILE: src/react/hooks/__tests__/useLoadableQuery/deferGraphQL17Alpha9.test.tsx
function renderHook (line 28) | async function renderHook<
type Data (line 114) | interface Data {
type QueryData (line 255) | interface QueryData {
FILE: src/react/hooks/__tests__/useMutation.test.tsx
constant IS_REACT_17 (line 37) | const IS_REACT_17 = React.version.startsWith("17");
constant IS_REACT_18 (line 38) | const IS_REACT_18 = React.version.startsWith("18");
constant IS_REACT_19 (line 39) | const IS_REACT_19 = React.version.startsWith("19");
type Todo (line 42) | interface Todo {
method read (line 2068) | read(ms: number = Date.now()) {
method merge (line 2072) | merge(existing, incoming: number) {
method update (line 2107) | update(cache, { data }) {
method read (line 2192) | read(ms: number = Date.now()) {
method merge (line 2196) | merge(existing, incoming: number) {
method update (line 2237) | update(cache, { data }) {
method update (line 2326) | update(_, __, options) {
method update (line 2371) | update(_, __, options) {
method update (line 2415) | update(_, __, options) {
method update (line 2563) | update(_, __, options) {
type TData (line 2640) | interface TData {
method todoCount (line 2668) | todoCount(count = 0) {
type OnQueryUpdatedResults (line 2691) | interface OnQueryUpdatedResults {
method update (line 2718) | update(cache) {
method onQueryUpdated (line 2766) | async onQueryUpdated(obsQuery, diff) {
method update (line 3410) | update() {
type TNumbersQuery (line 3464) | type TNumbersQuery = {
function getNumbersData (line 3476) | function getNumbersData(length: number = totalNumbers): TNumbersQuery {
method sum (line 3518) | sum(_, { readField }) {
function App (line 3562) | function App() {
function getNextSnapshot (line 3602) | async function getNextSnapshot() {
function getLastNumber (line 3614) | function getLastNumber() {
method onQueryUpdated (line 3722) | onQueryUpdated(oq, diff) {
method onQueryUpdated (line 3788) | onQueryUpdated(oq, diff) {
type Mutation (line 3928) | interface Mutation {
type Mutation (line 4036) | interface Mutation {
type Mutation (line 4147) | interface Mutation {
method refetchQueries (line 4275) | refetchQueries(result) {
method onCompleted (line 4280) | onCompleted(data) {
method update (line 4283) | update(_, result) {
type Mutation (line 4293) | interface Mutation {
type Variables (line 4301) | interface Variables {
method refetchQueries (line 4342) | refetchQueries(result) {
method onCompleted (line 4347) | onCompleted(data) {
method update (line 4350) | update(_, result) {
type UserFieldsFragment (line 4362) | type UserFieldsFragment = {
type Mutation (line 4367) | type Mutation = {
type UnmaskedMutation (line 4374) | type UnmaskedMutation = {
type Variables (line 4382) | interface Variables {
method refetchQueries (line 4423) | refetchQueries(result) {
method onCompleted (line 4430) | onCompleted(data) {
method update (line 4433) | update(_, result) {
FILE: src/react/hooks/__tests__/useMutation/defer20220824.test.tsx
constant CREATE_TODO_ERROR (line 17) | const CREATE_TODO_ERROR = "Failed to create item";
FILE: src/react/hooks/__tests__/useMutation/deferGraphQL17Alpha9.test.tsx
constant CREATE_TODO_ERROR (line 17) | const CREATE_TODO_ERROR = "Failed to create item";
FILE: src/react/hooks/__tests__/useQuery.test.tsx
constant IS_REACT_17 (line 68) | const IS_REACT_17 = React.version.startsWith("17");
constant IS_REACT_18 (line 69) | const IS_REACT_18 = React.version.startsWith("18");
method update (line 852) | update(cache, { data }) {
function WrapperComponent (line 1027) | function WrapperComponent({ something }: any) {
type Data (line 1597) | interface Data {
type Data (line 1687) | interface Data {
type Variables (line 1695) | interface Variables {
type Data (line 1777) | interface Data {
type Data (line 1840) | interface Data {
type Opts (line 1868) | type Opts = SkipToken | useQuery.Options<Data, { id: number }>;
function checkObservableQueries (line 2038) | function checkObservableQueries(expectedLinkCount: number) {
type Opts (line 2426) | type Opts = SkipToken | useQuery.Options;
function onDogSelected (line 4235) | function onDogSelected(event: React.ChangeEvent<HTMLSelectElement>) {
method merge (line 5661) | merge(existing, incoming, { args }) {
type Query1 (line 5776) | interface Query1 {
type Query2 (line 5785) | interface Query2 {
type Variables (line 5789) | interface Variables {
function App (line 5847) | function App() {
type Query1 (line 6079) | interface Query1 {
type Query2 (line 6087) | interface Query2 {
type Variables (line 6096) | interface Variables {
function App (line 6160) | function App() {
type Query1 (line 6342) | interface Query1 {
type Query2 (line 6351) | interface Query2 {
type Variables (line 6359) | interface Variables {
function App (line 6423) | function App() {
function App (line 6776) | function App() {
method merge (line 7206) | merge(existing, incoming) {
method merge (line 7313) | merge(existing, incoming) {
method merge (line 7422) | merge(existing, incoming) {
method update (line 7774) | update(cache, { data }) {
method titleLength (line 7929) | titleLength(data) {
method clientEntity (line 7934) | clientEntity(_root, { id }, { client }) {
method addOrUpdate (line 7944) | addOrUpdate(_root, { id, title }, { client }) {
type Opts (line 8245) | type Opts = SkipToken | useQuery.Options;
function check (line 8727) | function check(
method nextFetchPolicy (line 8768) | nextFetchPolicy(currentFetchPolicy, context) {
function check (line 8838) | function check(
method nextFetchPolicy (line 8879) | nextFetchPolicy(currentFetchPolicy, context) {
type Person (line 9825) | type Person = {
type ABFields (line 10011) | type ABFields = {
function makeClient (line 10054) | function makeClient() {
function check (line 10079) | async function check(
type TestQueryValue (line 10338) | type TestQueryValue = typeof cacheData;
type UserFieldsFragment (line 10885) | type UserFieldsFragment = {
type Query (line 10890) | interface Query {
function App (line 10937) | function App() {
type UserFieldsFragment (line 10988) | type UserFieldsFragment = {
type Query (line 10993) | interface Query {
function App (line 11046) | function App() {
type UserFieldsFragment (line 11086) | type UserFieldsFragment = {
type Query (line 11091) | interface Query {
function App (line 11142) | function App() {
type UserFieldsFragment (line 11180) | type UserFieldsFragment = {
type Query (line 11185) | interface Query {
function App (line 11232) | function App() {
type UserFieldsFragment (line 11308) | type UserFieldsFragment = {
type Query (line 11313) | interface Query {
function App (line 11360) | function App() {
type UserFieldsFragment (line 11424) | type UserFieldsFragment = {
type Query (line 11429) | interface Query {
function App (line 11488) | function App() {
type UserFieldsFragment (line 11523) | type UserFieldsFragment = {
type Query (line 11528) | interface Query {
function App (line 11588) | function App() {
type UserFieldsFragment (line 11649) | type UserFieldsFragment = {
type Query (line 11654) | interface Query {
function App (line 11718) | function App() {
type UserFieldsFragment (line 11777) | type UserFieldsFragment = {
type Query (line 11782) | interface Query {
function App (line 11831) | function App() {
method merge (line 12213) | merge(existing: number[] | undefined, incoming: number[]) {
type Data (line 12828) | type Data = typeof data;
type Vars (line 12829) | type Vars = { first: number };
type Data (line 12938) | type Data = typeof data;
type Vars (line 12939) | type Vars = { first: number };
type Query (line 13055) | interface Query {
type QueryVariables (line 13059) | interface QueryVariables {
type Result (line 13063) | type Result = Pick<
FILE: src/react/hooks/__tests__/useQuery/streamDefer20220824.test.tsx
function createLink (line 26) | function createLink(rootValue?: unknown) {
type Friend (line 44) | type Friend = (typeof friends)[number];
FILE: src/react/hooks/__tests__/useQuery/streamGraphQL17Alpha9.test.tsx
function createLink (line 26) | function createLink(rootValue?: unknown) {
type Friend (line 44) | type Friend = (typeof friends)[number];
FILE: src/react/hooks/__tests__/useQueryRefHandlers.test.tsx
function SuspenseFallback (line 62) | function SuspenseFallback() {
function ReadQueryHook (line 67) | function ReadQueryHook() {
function App (line 74) | function App() {
function SuspenseFallback (line 166) | function SuspenseFallback() {
function ReadQueryHook (line 171) | function ReadQueryHook() {
function App (line 177) | function App() {
type QueryData (line 240) | interface QueryData {
method merge (line 264) | merge(existing: number[] | undefined, incoming: number[]) {
function SuspenseFallback (line 293) | function SuspenseFallback() {
function ReadQueryHook (line 298) | function ReadQueryHook() {
function App (line 304) | function App() {
type QueryData (line 369) | interface QueryData {
method merge (line 393) | merge(existing: number[] | undefined, incoming: number[]) {
function SuspenseFallback (line 422) | function SuspenseFallback() {
function ReadQueryHook (line 427) | function ReadQueryHook() {
function App (line 433) | function App() {
type QueryData (line 495) | interface QueryData {
method merge (line 519) | merge(existing: number[] | undefined, incoming: number[]) {
function SuspenseFallback (line 547) | function SuspenseFallback() {
function ReadQueryHook (line 552) | function ReadQueryHook() {
function App (line 558) | function App() {
type Variables (line 611) | type Variables = {
type Data (line 615) | interface Data {
function App (line 667) | function App() {
function SuspenseFallback (line 693) | function SuspenseFallback() {
function Todo (line 698) | function Todo() {
function SuspenseFallback (line 804) | function SuspenseFallback() {
function ReadQueryHook (line 809) | function ReadQueryHook({ queryRef }: { queryRef: QueryRef<SimpleCaseData...
function App (line 832) | function App() {
function SuspenseFallback (line 973) | function SuspenseFallback() {
function ReadQueryHook (line 978) | function ReadQueryHook({ queryRef }: { queryRef: QueryRef<SimpleCaseData...
function App (line 985) | function App() {
function SuspenseFallback (line 1063) | function SuspenseFallback() {
function ReadQueryHook (line 1068) | function ReadQueryHook({ queryRef }: { queryRef: QueryRef<SimpleCaseData...
function App (line 1075) | function App() {
function SuspenseFallback (line 1159) | function SuspenseFallback() {
function ReadQueryHook (line 1164) | function ReadQueryHook() {
function App (line 1171) | function App() {
function SuspenseFallback (line 1254) | function SuspenseFallback() {
function ReadQueryHook (line 1259) | function ReadQueryHook() {
function App (line 1266) | function App() {
function SuspenseFallback (line 1369) | function SuspenseFallback() {
function ReadQueryHook (line 1374) | function ReadQueryHook() {
function App (line 1381) | function App() {
function SuspenseFallback (line 1475) | function SuspenseFallback() {
function ReadQueryHook (line 1480) | function ReadQueryHook({
function App (line 1497) | function App() {
function SuspenseFallback (line 1581) | function SuspenseFallback() {
function ReadQueryHook (line 1586) | function ReadQueryHook({
function App (line 1603) | function App() {
function SuspenseFallback (line 1697) | function SuspenseFallback() {
function ReadQueryHook (line 1702) | function ReadQueryHook() {
function App (line 1709) | function App() {
function SuspenseFallback (line 1831) | function SuspenseFallback() {
function ReadQueryHook (line 1836) | function ReadQueryHook({
function App (line 1863) | function App() {
type SubscriptionData (line 2004) | interface SubscriptionData {
type UpdateQueryFn (line 2008) | type UpdateQueryFn = SubscribeToMoreUpdateQueryFn<
function SuspenseFallback (line 2057) | function SuspenseFallback() {
function ReadQueryHook (line 2062) | function ReadQueryHook() {
function App (line 2069) | function App() {
FILE: src/react/hooks/__tests__/useReactiveVar.test.tsx
constant IS_REACT_18 (line 7) | const IS_REACT_18 = React.version.startsWith("18");
constant IS_REACT_19 (line 8) | const IS_REACT_19 = React.version.startsWith("19");
function Component (line 15) | function Component() {
function Parent (line 53) | function Parent() {
function Child (line 74) | function Child() {
function Component (line 136) | function Component() {
function ComponentOne (line 190) | function ComponentOne() {
function ComponentTwo (line 200) | function ComponentTwo() {
function ComponentOne (line 221) | function ComponentOne() {
function ComponentTwo (line 227) | function ComponentTwo() {
function Component (line 253) | function Component() {
function Component (line 290) | function Component() {
function App (line 318) | function App() {
function spam (line 331) | function spam() {
FILE: src/react/hooks/__tests__/useSubscription.test.tsx
constant IS_REACT_17 (line 28) | const IS_REACT_17 = React.version.startsWith("17");
function Subscription (line 1006) | function Subscription({ idx }: { idx: number }) {
function App (line 1011) | function App({ count }: { count: number }) {
function Subscription (line 1211) | function Subscription({
function App (line 1222) | function App({
function Subscription (line 1348) | function Subscription({ idx }: { idx: number }) {
function App (line 1357) | function App({ count }: { count: number }) {
function Subscription (line 1557) | function Subscription({
function App (line 1568) | function App({ options }: { options: useSubscription.Options[] }) {
function setup (line 1959) | async function setup(
function setup (line 2241) | async function setup(
function Subscription (line 2680) | function Subscription({ idx }: { idx: number }) {
function App (line 2685) | function App({ count }: { count: number }) {
type UserFieldsFragment (line 3577) | type UserFieldsFragment = {
type Subscription (line 3581) | interface Subscription {
type UserFieldsFragment (line 3601) | type UserFieldsFragment = {
type Subscription (line 3606) | interface Subscription {
FILE: src/react/hooks/__tests__/useSuspenseFragment.test.tsx
function createDefaultRenderStream (line 32) | function createDefaultRenderStream<TData = unknown>() {
function createDefaultTrackedComponents (line 40) | function createDefaultTrackedComponents() {
type ItemFragment (line 87) | interface ItemFragment {
function App (line 109) | function App() {
type ItemFragment (line 166) | interface ItemFragment {
function App (line 188) | function App() {
type ItemFragment (line 267) | interface ItemFragment {
function App (line 289) | function App() {
type ItemFragment (line 381) | interface ItemFragment {
function App (line 408) | function App() {
type ItemFragment (line 450) | interface ItemFragment {
function App (line 477) | function App() {
type ItemFragment (line 537) | interface ItemFragment {
type ItemFragment (line 590) | interface ItemFragment {
function App (line 618) | function App({ id }: { id: number }) {
type ItemFragment (line 689) | interface ItemFragment {
function App (line 722) | function App({ id }: { id: number }) {
type ItemFragment (line 782) | interface ItemFragment {
type ItemFragment (line 840) | interface ItemFragment {
type Fragment (line 913) | interface Fragment {
function App (line 932) | function App() {
type ItemFragment (line 970) | interface ItemFragment {
type ItemFragment (line 1004) | interface ItemFragment {
type ItemFragment (line 1068) | interface ItemFragment {
type ItemFragment (line 1132) | interface ItemFragment {
function App (line 1154) | function App({ id }: { id: number | null }) {
type Post (line 1223) | type Post = {
type PostFields (line 1229) | type PostFields = {
type Post (line 1294) | type Post = {
type PostFields (line 1300) | type PostFields = {
type Post (line 1376) | type Post = {
type PostFields (line 1382) | type PostFields = {
function Parent (line 1427) | function Parent() {
function Child (line 1440) | function Child({ post }: { post: FragmentType<PostFields> }) {
type ItemFragment (line 1514) | interface ItemFragment {
type ItemFragment (line 1562) | interface ItemFragment {
type ItemFragment (line 1623) | interface ItemFragment {
function App (line 1641) | function App() {
function Item (line 1656) | function Item() {
type ItemFragment (line 1696) | interface ItemFragment {
function App (line 1724) | function App() {
function Item (line 1739) | function Item() {
type ItemFragment (line 1779) | interface ItemFragment {
function App (line 1796) | function App() {
function Item (line 1806) | function Item() {
type ItemFragment (line 1840) | interface ItemFragment {
function App (line 1871) | function App() {
type Data (line 1928) | type Data = { foo: string };
type Data (line 1951) | type Data = { foo: string };
type Vars (line 1952) | type Vars = Record<string, never>;
type Post (line 1972) | type Post = { __typename: "Post"; id: number };
type Vars (line 1973) | type Vars = Record<string, never>;
type Data (line 1994) | type Data = { foo: string };
type Vars (line 1995) | type Vars = Record<string, never>;
type Data (line 2015) | type Data = { foo: string };
type Vars (line 2016) | type Vars = Record<string, never>;
type Data (line 2039) | type Data = { foo: string };
type Vars (line 2040) | type Vars = Record<string, never>;
FILE: src/react/hooks/__tests__/useSuspenseFragment/arrays.test.tsx
function renderUseSuspenseFragment (line 16) | async function renderUseSuspenseFragment<TData, Props = never>(
type Item (line 55) | type Item = {
type Item (line 109) | type Item = {
type Item (line 232) | type Item = {
type Item (line 267) | type Item = {
type Item (line 317) | type Item = {
type Item (line 359) | type Item = {
type Item (line 433) | type Item = {
type Item (line 500) | type Item = {
type Item (line 588) | type Item = {
type Item (line 720) | type Item = {
function UseSuspenseFragment (line 739) | function UseSuspenseFragment({
function SuspenseFallback (line 754) | function SuspenseFallback({ id }: { id: number }) {
function App (line 763) | function App({
type Item (line 953) | type Item = {
function UseSuspenseFragment (line 972) | function UseSuspenseFragment({ items }: { items: StoreObject[] }) {
function SuspenseFallback (line 979) | function SuspenseFallback() {
function App (line 985) | function App() {
FILE: src/react/hooks/__tests__/useSuspenseQuery.test.tsx
constant IS_REACT_19 (line 73) | const IS_REACT_19 = React.version.startsWith("19");
type RenderSuspenseHookOptions (line 75) | type RenderSuspenseHookOptions<Props> = Omit<
type Renders (line 87) | interface Renders<Result> {
type SimpleQueryData (line 95) | interface SimpleQueryData {
function renderSuspenseHook (line 104) | async function renderSuspenseHook<Result, Props>(
function useSimpleQueryCase (line 175) | function useSimpleQueryCase() {
type QueryData (line 194) | interface QueryData {
type Variables (line 201) | interface Variables {
function usePaginatedCase (line 206) | function usePaginatedCase({ delay = 10 } = {}) {
type ErrorCaseData (line 240) | interface ErrorCaseData {
function useErrorCase (line 247) | function useErrorCase<TData extends ErrorCaseData>({
type VariablesCaseData (line 274) | interface VariablesCaseData {
type VariablesCaseVariables (line 281) | interface VariablesCaseVariables {
function useVariablesQueryCase (line 285) | function useVariablesQueryCase() {
type CharacterFragment (line 314) | type CharacterFragment = {
type MaskedVariablesCaseData (line 319) | interface MaskedVariablesCaseData {
type UnmaskedVariablesCaseData (line 326) | interface UnmaskedVariablesCaseData {
function useMaskedVariablesQueryCase (line 334) | function useMaskedVariablesQueryCase() {
function wait (line 372) | function wait(delay: number) {
function App (line 784) | function App() {
function Greeting (line 799) | function Greeting() {
function App (line 850) | function App() {
function Greeting (line 865) | function Greeting() {
function App (line 915) | function App() {
function Greeting (line 925) | function Greeting() {
function App (line 967) | function App() {
function Greeting (line 977) | function Greeting() {
type Data (line 1210) | interface Data {
type Variables (line 1218) | interface Variables {
function Spinner (line 1257) | function Spinner({ name }: { name: string }) {
function App (line 1261) | function App() {
function Todo (line 1274) | function Todo({ name }: { name: string }) {
type Variables (line 4521) | type Variables = {
type Data (line 4524) | interface Data {
function App (line 4564) | function App() {
function SuspenseFallback (line 4574) | function SuspenseFallback() {
function Todo (line 4578) | function Todo({ id }: { id: string }) {
function Component (line 5095) | function Component() {
function SuspenseFallback (line 5102) | function SuspenseFallback() {
function ErrorFallback (line 5106) | function ErrorFallback() {
function App (line 5110) | function App() {
function App (line 5175) | function App() {
function SuspenseFallback (line 5185) | function SuspenseFallback() {
function Letters (line 5189) | function Letters({ offset }: { offset: number }) {
method merge (line 5417) | merge(existing: number[] | undefined, incoming: number[]) {
method merge (line 5496) | merge(existing: number[] | undefined, incoming: number[]) {
method merge (line 5578) | merge(existing: number[] | undefined, incoming: number[]) {
type Variables (line 6103) | type Variables = {
type Data (line 6106) | interface Data {
function App (line 6146) | function App() {
function SuspenseFallback (line 6156) | function SuspenseFallback() {
function Todo (line 6160) | function Todo({ id }: { id: string }) {
type Variables (line 6208) | type Variables = {
type Data (line 6211) | interface Data {
function App (line 6243) | function App() {
function SuspenseFallback (line 6266) | function SuspenseFallback() {
function Todo (line 6270) | function Todo({ id }: { id: string | null }) {
type Variables (line 6308) | type Variables = {
type Data (line 6311) | interface Data {
function App (line 6343) | function App() {
function SuspenseFallback (line 6366) | function SuspenseFallback() {
function Todo (line 6370) | function Todo({ id }: { id: string | null }) {
method merge (line 6590) | merge(existing: number[] | undefined, incoming: number[]) {
function Component (line 6742) | function Component({ returnPartialData }: { returnPartialData: boolean }) {
function SuspenseFallback (line 6749) | function SuspenseFallback() {
function ErrorFallback (line 6753) | function ErrorFallback() {
function App (line 6757) | function App({ returnPartialData }: { returnPartialData: boolean }) {
type SubscriptionData (line 7167) | interface SubscriptionData {
type QueryData (line 7171) | interface QueryData {
type UpdateQueryFn (line 7175) | type UpdateQueryFn = NonNullable<
type Variables (line 7273) | interface Variables {
type Data (line 7277) | interface Data {
function App (line 7305) | function App() {
function SuspenseFallback (line 7325) | function SuspenseFallback() {
function Results (line 7329) | function Results({ query }: { query: string }) {
type Variables (line 7374) | type Variables = {
type Data (line 7378) | interface Data {
function App (line 7419) | function App() {
function SuspenseFallback (line 7431) | function SuspenseFallback() {
function Todo (line 7435) | function Todo({
type Variables (line 7517) | type Variables = {
type Data (line 7521) | interface Data {
function App (line 7562) | function App() {
function SuspenseFallback (line 7572) | function SuspenseFallback() {
function Todo (line 7576) | function Todo({ id }: { id: string }) {
type Variables (line 7636) | type Variables = {
type Todo (line 7640) | interface Todo {
type Data (line 7647) | interface Data {
function App (line 7710) | function App() {
function SuspenseFallback (line 7720) | function SuspenseFallback() {
function Todos (line 7724) | function Todos() {
function SuspenseFallback (line 7871) | function SuspenseFallback() {
function App (line 7877) | function App() {
type Variables (line 7971) | type Variables = {
type Todo (line 7975) | interface Todo {
type Data (line 7981) | interface Data {
function SuspenseFallback (line 8041) | function SuspenseFallback() {
function App (line 8065) | function App() {
function App (line 8249) | function App() {
function SuspenseFallback (line 8375) | function SuspenseFallback() {
function ErrorFallback (line 8381) | function ErrorFallback({ error }: FallbackProps) {
function App (line 8388) | function App() {
type UserFieldsFragment (line 8457) | type UserFieldsFragment = {
type Query (line 8461) | interface Query {
function App (line 8514) | function App() {
type UserFieldsFragment (line 8552) | type UserFieldsFragment = {
type Query (line 8556) | interface Query {
function App (line 8609) | function App() {
type UserFieldsFragment (line 8645) | type UserFieldsFragment = {
type Query (line 8649) | interface Query {
function App (line 8701) | function App() {
type UserFieldsFragment (line 8737) | type UserFieldsFragment = {
type Query (line 8741) | interface Query {
function App (line 8794) | function App() {
type UserFieldsFragment (line 8859) | type UserFieldsFragment = {
type Query (line 8863) | interface Query {
function App (line 8916) | function App() {
type UserFieldsFragment (line 8978) | type UserFieldsFragment = {
type Query (line 8982) | interface Query {
function App (line 9047) | function App() {
type UserFieldsFragment (line 9079) | type UserFieldsFragment = {
type Query (line 9083) | interface Query {
function App (line 9149) | function App() {
type UserFieldsFragment (line 9197) | type UserFieldsFragment = {
type Query (line 9202) | interface Query {
function App (line 9272) | function App() {
type UserFieldsFragment (line 9317) | type UserFieldsFragment = {
type Query (line 9321) | interface Query {
function App (line 9377) | function App() {
type Query (line 9429) | interface Query {
type QueryVariables (line 9432) | interface QueryVariables {
type Result (line 9435) | type Result = Pick<
function App (line 9514) | function App() {
type CharacterFragment (line 11688) | type CharacterFragment = {
type Subscription (line 11693) | type Subscription = {
type UnmaskedSubscription (line 11700) | type UnmaskedSubscription = {
FILE: src/react/hooks/__tests__/useSuspenseQuery/defer20220824.test.tsx
function renderSuspenseHook (line 31) | async function renderSuspenseHook<
FILE: src/react/hooks/__tests__/useSuspenseQuery/deferGraphQL17Alpha9.test.tsx
function renderSuspenseHook (line 31) | async function renderSuspenseHook<
FILE: src/react/hooks/__tests__/useSuspenseQuery/streamDefer20220824.test.tsx
function renderSuspenseHook (line 35) | async function renderSuspenseHook<
function createLink (line 99) | function createLink(rootValue?: unknown) {
type Friend (line 117) | type Friend = (typeof friends)[number];
FILE: src/react/hooks/__tests__/useSuspenseQuery/streamGraphQL17Alpha9.test.tsx
function renderSuspenseHook (line 35) | async function renderSuspenseHook<
function createLink (line 99) | function createLink(rootValue?: unknown) {
type Friend (line 117) | type Friend = (typeof friends)[number];
FILE: src/react/hooks/__tests__/useSuspenseQuery/testUtils.tsx
function renderUseSuspenseQuery (line 13) | async function renderUseSuspenseQuery<
FILE: src/react/hooks/constants.ts
type SkipToken (line 2) | type SkipToken = typeof skipToken;
FILE: src/react/hooks/internal/__tests__/useRenderGuard.test.tsx
constant UNDEF (line 9) | const UNDEF = {};
constant IS_REACT_19 (line 10) | const IS_REACT_19 = React.version.startsWith("19");
function TestComponent (line 16) | function TestComponent() {
function TestComponent (line 27) | function TestComponent() {
FILE: src/react/hooks/internal/__use.ts
type Use (line 5) | type Use = <T>(promise: Promise<T>) => T;
FILE: src/react/hooks/internal/useDeepMemo.ts
function useDeepMemo (line 5) | function useDeepMemo<TValue>(
FILE: src/react/hooks/internal/useRenderGuard.ts
function noop (line 5) | function noop() {}
function useRenderGuard (line 6) | function useRenderGuard() {
FILE: src/react/hooks/internal/useSuspenseHookCacheKey.ts
type Options (line 12) | interface Options {
function useSuspenseHookCacheKey (line 18) | function useSuspenseHookCacheKey(
FILE: src/react/hooks/internal/validateSuspenseHookOptions.ts
function validateSuspenseHookOptions (line 8) | function validateSuspenseHookOptions<
function validateFetchPolicy (line 18) | function validateFetchPolicy(
function validatePartialDataReturn (line 35) | function validatePartialDataReturn(
FILE: src/react/hooks/internal/wrapHook.ts
type FunctionSignature (line 20) | type FunctionSignature<T> =
type WrappableHooks (line 23) | interface WrappableHooks {
type HookWrappers (line 39) | type HookWrappers = {
type QueryManagerWithWrappers (line 45) | interface QueryManagerWithWrappers extends InternalTypes.QueryManager {
function wrapHook (line 85) | function wrapHook<Hook extends (...args: any[]) => any>(
FILE: src/react/hooks/useApolloClient.ts
function useApolloClient (line 23) | function useApolloClient(override?: ApolloClient): ApolloClient {
FILE: src/react/hooks/useBackgroundQuery.ts
type FetchPolicy (line 39) | type FetchPolicy = Extract<
type Options (line 45) | interface Options {
type Options (line 85) | type Options<
type Options (line 91) | interface Options<
type Result (line 98) | interface Result<
type Result (line 124) | interface Result<
function useBackgroundQuery (line 415) | function useBackgroundQuery<
function useBackgroundQuery_ (line 433) | function useBackgroundQuery_<
FILE: src/react/hooks/useFragment.ts
type Options (line 22) | interface Options<TData, TVariables extends OperationVariables> {
type Options (line 75) | interface Options<
type FromOptionValue (line 85) | type FromOptionValue<TData> = ApolloCache.FromOptionValue<TData>;
type Result (line 89) | type Result<TData> =
type Result (line 111) | interface Result<TData> {
function useFragment (line 179) | function useFragment<
function useFragment_ (line 193) | function useFragment_<TData, TVariables extends OperationVariables>(
FILE: src/react/hooks/useLazyQuery.ts
type Options (line 41) | interface Options<
type Options (line 80) | interface Options<
type Result (line 88) | interface Result<TData, TVariables extends OperationVariables> {
type Result (line 139) | type Result<
type Result (line 177) | interface Result<TData, TVariables extends OperationVariables>
type ExecOptions (line 191) | type ExecOptions<
type ExecOptions (line 200) | interface ExecOptions<TVariables extends OperationVariables>
type ResultTuple (line 208) | type ResultTuple<
type ExecFunction (line 218) | type ExecFunction<TData, TVariables extends OperationVariables> = (
constant EAGER_METHODS (line 244) | const EAGER_METHODS = [
function useLazyQuery (line 330) | function useLazyQuery<
FILE: src/react/hooks/useLoadableQuery.ts
type ResetFunction (line 37) | type ResetFunction = () => void;
type LoadQueryFunction (line 40) | type LoadQueryFunction<TVariables extends OperationVariables> = (
type Result (line 49) | type Result<
type Handlers (line 59) | interface Handlers<
type FetchPolicy (line 75) | type FetchPolicy = Extract<
type Options (line 80) | interface Options {
function useLoadableQuery (line 214) | function useLoadableQuery<
function useWatchQueryOptions (line 338) | function useWatchQueryOptions<TData, TVariables extends OperationVariabl...
FILE: src/react/hooks/useMutation
Copy disabled (too large)
Download .json
Condensed preview — 936 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (12,718K chars).
[
{
"path": ".api-reports/api-report-cache.api.md",
"chars": 40995,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-core.api.md",
"chars": 49737,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-dev.api.md",
"chars": 958,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-errors.api.md",
"chars": 5943,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-incremental.api.md",
"chars": 9510,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link.api.md",
"chars": 4933,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_batch-http.api.md",
"chars": 1409,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_batch.api.md",
"chars": 1148,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_client-awareness.api.md",
"chars": 1077,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_context.api.md",
"chars": 1451,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_error.api.md",
"chars": 1154,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_http.api.md",
"chars": 4596,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_persisted-queries.api.md",
"chars": 2508,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_remove-typename.api.md",
"chars": 965,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_retry.api.md",
"chars": 1681,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_schema.api.md",
"chars": 1487,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_subscriptions.api.md",
"chars": 580,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_utils.api.md",
"chars": 607,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-link_ws.api.md",
"chars": 872,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-local-state.api.md",
"chars": 5075,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-masking.api.md",
"chars": 9986,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-react.api.md",
"chars": 58473,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-react_compiled.api.md",
"chars": 120673,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-react_internal.api.md",
"chars": 11253,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-react_internal_compiler-runtime.api.md",
"chars": 240,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-react_ssr.api.md",
"chars": 3093,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-testing.api.md",
"chars": 4777,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-testing_internal.api.md",
"chars": 10952,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-testing_react.api.md",
"chars": 1667,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities.api.md",
"chars": 8572,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities_environment.api.md",
"chars": 265,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities_internal.api.md",
"chars": 19878,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities_internal_globals.api.md",
"chars": 392,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities_internal_ponyfills.api.md",
"chars": 355,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities_invariant.api.md",
"chars": 1765,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-utilities_subscriptions_relay.api.md",
"chars": 973,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-v4-migration.api.md",
"chars": 11298,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report-zz_removals.api.md",
"chars": 11137,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".api-reports/api-report.api.md",
"chars": 117341,
"preview": "## API Report File for \"@apollo/client\"\n\n> Do not edit this file. It is a report generated by [API Extractor](https://ap"
},
{
"path": ".attw.json",
"chars": 58,
"preview": "{\n \"ignoreRules\": [\"false-esm\", \"cjs-resolves-to-esm\"]\n}\n"
},
{
"path": ".changeset/README.md",
"chars": 510,
"preview": "# Changesets\n\nHello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that wo"
},
{
"path": ".changeset/config.json",
"chars": 331,
"preview": "{\n \"$schema\": \"https://unpkg.com/@changesets/config@2.2.0/schema.json\",\n \"changelog\": [\n \"@changesets/changelog-git"
},
{
"path": ".circleci/config.yml",
"chars": 6271,
"preview": "version: 2.1\n\njobs:\n # Filesize:\n # docker:\n # - image: cimg/node:20.2.0\n # steps:\n # - checkout\n # "
},
{
"path": ".claude/commands/chores.md",
"chars": 693,
"preview": "---\nallowed-tools: Bash(git commit:*)\ndescription: Chores\n---\n\n## Context\n\n- Current git status: !`git status`\n- Current"
},
{
"path": ".claude/documentation.md",
"chars": 5106,
"preview": "# Documentation specific instructions\n\nDocumentation can be found in the `docs/` directory and in the `src/` directory a"
},
{
"path": ".claude/hooks.md",
"chars": 8832,
"preview": "# React Hooks\n\nReact Hooks can be found in the `src/react/hooks` directory.\nThis folder contains React Hooks and their a"
},
{
"path": ".claude/settings.json",
"chars": 239,
"preview": "{\n \"permissions\": {\n \"allow\": [\n \"Bash(git add:*)\",\n \"Bash(git fetch:*)\",\n \"Bash(git status:*)\",\n "
},
{
"path": ".git-blame-ignore-revs",
"chars": 590,
"preview": "# format \"ObservableQuery\" test\n0a67647b73abd94b706242f32b88d21a1400ad50\n# format \"ObservableQuery\" test (in #10597)\n104"
},
{
"path": ".gitattributes",
"chars": 19,
"preview": "* text=auto eol=lf\n"
},
{
"path": ".github/CODEOWNERS",
"chars": 63,
"preview": "* @apollographql/client-typescript\n\n/docs/ @apollographql/docs\n"
},
{
"path": ".github/ISSUE_TEMPLATE/bug.yml",
"chars": 2078,
"preview": "name: Bug\ndescription: File a bug report\nbody:\n - type: markdown\n attributes:\n value: \"Hello from the Apollo Cl"
},
{
"path": ".github/ISSUE_TEMPLATE/feature-request.md",
"chars": 408,
"preview": "---\nname: 🚀 Feature Request\nabout: Feature requests are managed in the Apollo Feature Request repo (https://github.com/a"
},
{
"path": ".github/ISSUE_TEMPLATE/question-discussion.md",
"chars": 519,
"preview": "---\nname: 🤗 Question / Discussion\nabout: Questions / discussions are best posted in our community forums or StackOverflo"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 1228,
"preview": "<!--\n Thanks for filing a pull request on Apollo Client!\n\n A few automated bots may chime in on your PR. They are here"
},
{
"path": ".github/dependabot.yml",
"chars": 396,
"preview": "# Please see the documentation for all configuration options:\n# https://help.github.com/github/administering-a-repositor"
},
{
"path": ".github/instructions/apollo-client.instructions.md",
"chars": 1206,
"preview": "---\napplyTo: \"**\"\n---\n\n# Apollo Client Skill Usage Instructions\n\n## When to Use the Apollo Client Skill\n\nUse the `apollo"
},
{
"path": ".github/workflows/api-extractor.yml",
"chars": 563,
"preview": "name: Api Extractor\non: pull_request\n\nconcurrency: ${{ github.workflow }}-${{ github.ref }}\n\njobs:\n api-extractor:\n "
},
{
"path": ".github/workflows/arethetypeswrong.yml",
"chars": 691,
"preview": "name: AreTheTypesWrong\non:\n pull_request:\n branches:\n - main\n - release-*\n\nconcurrency: ${{ github.workflo"
},
{
"path": ".github/workflows/change-prerelease-tag.yml",
"chars": 2111,
"preview": "name: Change Prerelease Tag\n\non:\n workflow_dispatch:\n inputs:\n branch:\n description: \"Branch name\"\n "
},
{
"path": ".github/workflows/cleanup-checks.mjs",
"chars": 409,
"preview": "// @ts-check\n/** @param {import('@actions/github-script').AsyncFunctionArguments} AsyncFunctionArguments */\nexport funct"
},
{
"path": ".github/workflows/cleanup-checks.yml",
"chars": 1928,
"preview": "name: Clean up Prettier, Size-limit, and Api-Extractor\n\non:\n pull_request:\n pull_request_review:\n types: [submitted"
},
{
"path": ".github/workflows/close-stale-issues.yml",
"chars": 10833,
"preview": "# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.\n#\n# You c"
},
{
"path": ".github/workflows/compare-build-output.yml",
"chars": 823,
"preview": "name: Compare Build Output\non:\n pull_request:\n\nconcurrency: ${{ github.workflow }}-${{ github.ref }}\n\njobs:\n comparebu"
},
{
"path": ".github/workflows/copilot-setup-steps.yml",
"chars": 3058,
"preview": "name: \"Copilot Setup Steps\"\n\n# Automatically run the setup steps when they are changed to allow for easy validation, and"
},
{
"path": ".github/workflows/devtools-errorcodes.yml",
"chars": 715,
"preview": "name: Devtools - Trigger Error Code PR after npm Release\non:\n workflow_dispatch: # for testing\n workflow_run:\n work"
},
{
"path": ".github/workflows/docmodel.yml",
"chars": 701,
"preview": "name: Generate Documentation Model\n\non:\n push:\n\njobs:\n docmodel:\n name: Generate Documentation Model\n runs-on: u"
},
{
"path": ".github/workflows/exit-prerelease.yml",
"chars": 1800,
"preview": "name: Exit Prerelease Mode\n\non:\n workflow_dispatch:\n inputs:\n branch:\n description: \"Exit prerelease mod"
},
{
"path": ".github/workflows/issue-close-user-survey.yml",
"chars": 1150,
"preview": "name: Issue Close User Survey\n\non:\n issues:\n types: [closed]\n\njobs:\n user-survey-comment:\n permissions:\n is"
},
{
"path": ".github/workflows/knip.yml",
"chars": 343,
"preview": "name: Look for dead code and unused dependencies\n\non: push\n\njobs:\n lint:\n runs-on: ubuntu-latest\n name: Ubuntu/No"
},
{
"path": ".github/workflows/lock.yml",
"chars": 925,
"preview": "name: \"Lock Threads\"\n\non:\n schedule:\n - cron: \"0 0 * * *\"\n\npermissions:\n issues: write\n pull-requests: write\n\nconc"
},
{
"path": ".github/workflows/prerelease.yml",
"chars": 2878,
"preview": "name: Prerelease\n\non:\n push:\n branches:\n # Target release-x.x branches\n - \"release-*\"\n\nconcurrency: ${{ gi"
},
{
"path": ".github/workflows/publish-pr-releases.yml",
"chars": 1756,
"preview": "name: Pull Request Prerelease\n\non:\n pull_request:\n push:\n branches:\n - \"**\"\n tags:\n - \"!**\"\n\njobs:\n p"
},
{
"path": ".github/workflows/release.yml",
"chars": 5910,
"preview": "name: Release\n\non:\n push:\n branches:\n - main\n - version-3.x\n - \"release-*\"\n\nconcurrency: ${{ github.w"
},
{
"path": ".github/workflows/scheduled-test-canary.yml",
"chars": 1572,
"preview": "# a GitHub Action that once a day runs all tests from `main` and `release-*` branches\n# with the latest `canary` and `ex"
},
{
"path": ".github/workflows/size-limit.yml",
"chars": 543,
"preview": "name: \"size\"\non:\n pull_request:\n branches:\n - main\n - release-*\n - pr/*\njobs:\n size:\n runs-on: ub"
},
{
"path": ".gitignore",
"chars": 1198,
"preview": "# Installed via Github Copilot Setup Steps, should not be committed\n.agents/skills/apollo-client\n.github/instructions/do"
},
{
"path": ".npmrc",
"chars": 22,
"preview": "legacy-peer-deps=true\n"
},
{
"path": ".prettierignore",
"chars": 699,
"preview": "##### DISCLAIMER ######\n# We have disabled the use of prettier in this project for a variety of reasons.\n# Because much "
},
{
"path": ".prettierrc",
"chars": 630,
"preview": "{\n \"bracketSpacing\": true,\n \"printWidth\": 80,\n \"semi\": true,\n \"singleQuote\": false,\n \"tabWidth\": 2,\n \"trailingComm"
},
{
"path": ".semgrepignore",
"chars": 311,
"preview": "# semgrep defaults\n# https://semgrep.dev/docs/ignoring-files-folders-code#defining-ignored-files-and-folders-in-semgrepi"
},
{
"path": ".size-limit.cjs",
"chars": 2092,
"preview": "const limits = require(\"./.size-limits.json\");\n\nconst checks = [\n {\n import: { \"@apollo/client\": \"{ ApolloClient, In"
},
{
"path": ".size-limits.json",
"chars": 381,
"preview": "{\n \"import { ApolloClient, InMemoryCache, HttpLink } from \\\"@apollo/client\\\" (CJS)\": 46872,\n \"import { ApolloClient, I"
},
{
"path": ".vscode/launch.json",
"chars": 679,
"preview": "{\n \"version\": \"0.2.0\",\n \"configurations\": [\n {\n \"name\": \"NodeJS Attach\",\n \"port\": 9229,\n \"request\": "
},
{
"path": ".vscode/settings.json",
"chars": 622,
"preview": "// Place your settings in this file to overwrite default and user settings.\n{\n \"editor.tabSize\": 2,\n \"editor.rulers\": "
},
{
"path": "CHANGELOG.md",
"chars": 732217,
"preview": "# @apollo/client\n\n## 4.1.6\n\n### Patch Changes\n\n- [#13128](https://github.com/apollographql/apollo-client/pull/13128) [`6"
},
{
"path": "CLAUDE.md",
"chars": 4486,
"preview": "# CLAUDE.md\n\nThis file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.\n\n## "
},
{
"path": "COLLABORATORS.md",
"chars": 2161,
"preview": "# Apollo OSS Collaborator Guidelines\n\nThanks for helping make Apollo OSS better! Here are a few quick repo maintenance g"
},
{
"path": "CONTRIBUTING.md",
"chars": 11941,
"preview": "# Apollo Contributor Guide\n\nExcited about Apollo and want to make it better? We’re excited too!\n\nApollo is a community o"
},
{
"path": "LICENSE",
"chars": 1128,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2022 Apollo Graph, Inc. (Formerly Meteor Development Group, Inc.)\n\nPermission is he"
},
{
"path": "README.md",
"chars": 9707,
"preview": "<header>\n <div align=\"center\">\n <a href=\"https://www.apollographql.com?utm_medium=github&utm_source=apollographql_ap"
},
{
"path": "ROADMAP.md",
"chars": 1369,
"preview": "# 🔮 Apollo Client Ecosystem Roadmap\n\nFor up to date release notes, refer to the project's [Changelog](https://github.com"
},
{
"path": "VERSIONING_POLICY.md",
"chars": 6126,
"preview": "# Apollo Client Versioning Policy\n\nApollo Client tries to follow SemVer versioning.\n\nHowever, we reserve the right to ch"
},
{
"path": "api-extractor.json",
"chars": 4412,
"preview": "/**\n * Config file for API Extractor. For more info, please visit: https://api-extractor.com\n */\n{\n \"$schema\": \"https:"
},
{
"path": "codegen/CHANGELOG.md",
"chars": 5526,
"preview": "# @apollo/client-graphql-codegen\n\n## 2.0.0\n\n### Major Changes\n\n- [#13014](https://github.com/apollographql/apollo-client"
},
{
"path": "codegen/local-state/config.ts",
"chars": 11282,
"preview": "/**\n * Adapted from\n * https://github.com/dotansimha/graphql-code-generator/blob/master/packages/plugins/typescript/reso"
},
{
"path": "codegen/local-state/index.ts",
"chars": 97,
"preview": "export type { LocalStatePluginConfig } from \"./config.js\";\nexport { plugin } from \"./plugin.js\";\n"
},
{
"path": "codegen/local-state/plugin.ts",
"chars": 4489,
"preview": "/**\n * Adapted from\n * https://github.com/dotansimha/graphql-code-generator/blob/master/packages/plugins/typescript/reso"
},
{
"path": "codegen/local-state/visitor.ts",
"chars": 22563,
"preview": "/**\n * Adapted from\n * https://github.com/dotansimha/graphql-code-generator/blob/master/packages/plugins/typescript/reso"
},
{
"path": "codegen/package.json",
"chars": 1248,
"preview": "{\n \"name\": \"@apollo/client-graphql-codegen\",\n \"version\": \"2.0.0\",\n \"description\": \"Apollo Client GraphQL Codegen Plug"
},
{
"path": "codegen/tsconfig.json",
"chars": 405,
"preview": "{\n \"compilerOptions\": {\n \"noEmit\": false,\n \"target\": \"ESNext\",\n \"module\": \"nodenext\",\n \"moduleResolution\": "
},
{
"path": "config/FixJSDOMEnvironment.js",
"chars": 759,
"preview": "const { default: JSDOMEnvironment } = require(\"jest-environment-jsdom\");\n\n// https://github.com/facebook/jest/blob/v29.4"
},
{
"path": "config/apiExtractor.ts",
"chars": 6184,
"preview": "import { spawnSync } from \"node:child_process\";\nimport fs from \"node:fs\";\nimport { readFile, writeFile } from \"node:fs/p"
},
{
"path": "config/babel.ts",
"chars": 952,
"preview": "import { transformFromAstAsync } from \"@babel/core\";\n\nimport type { BuildStep } from \"./build.ts\";\nimport { applyRecast "
},
{
"path": "config/build.ts",
"chars": 3123,
"preview": "import { join, resolve } from \"node:path\";\nimport { parseArgs } from \"node:util\";\n\nimport { $ } from \"zx\";\n\nimport { bab"
},
{
"path": "config/bundlesize.ts",
"chars": 714,
"preview": "import { readFileSync } from \"fs\";\nimport { join } from \"path\";\nimport { gzipSync } from \"zlib\";\n\nimport bytes from \"byt"
},
{
"path": "config/compare-build-output-to.sh",
"chars": 2098,
"preview": "#!/usr/bin/env bash\nset -euo pipefail\nupstream=$1\ncomparison=\"${RUNNER_TEMP:-/tmp}/comparison_checkout\"\nroot=$(git rev-p"
},
{
"path": "config/compileTs.ts",
"chars": 5916,
"preview": "import { readFileSync } from \"node:fs\";\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport { join } from \"no"
},
{
"path": "config/deprecateInternals.ts",
"chars": 1123,
"preview": "import { visit } from \"recast\";\n\nimport type { BuildStep } from \"./build.ts\";\nimport { applyRecast, frameComment } from "
},
{
"path": "config/dirname.cjs",
"chars": 297,
"preview": "// workaround for `entryPoints.ts` that needs access to the current directory,\n// but cannot use `import.meta` as the fi"
},
{
"path": "config/entryPoints.ts",
"chars": 1509,
"preview": "import { readFileSync } from \"fs\";\nimport path from \"path\";\n\n// @ts-ignore An import path can only end with a '.cts' ext"
},
{
"path": "config/exports.ts",
"chars": 4070,
"preview": "import assert from \"node:assert\";\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { join } from \"n"
},
{
"path": "config/helpers.ts",
"chars": 9667,
"preview": "import * as assert from \"node:assert\";\nimport { glob, unlink, writeFile } from \"node:fs/promises\";\nimport { mkdir, readF"
},
{
"path": "config/inlineInheritDoc.ts",
"chars": 8222,
"preview": "/**\n * This build step will inline docblocks specified with `@inheritDoc` on build.\n *\n * E.g. a in a dockblock like thi"
},
{
"path": "config/jest/react-dom-17-client.js",
"chars": 385,
"preview": "// Shim for React 17 react-dom/client entrypoint imported by React Testing\n// Library\n\nmodule.exports = {\n hydrateRoot:"
},
{
"path": "config/jest.config.ts",
"chars": 3982,
"preview": "import { join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nconst defaults = {\n rootDir: \"src\",\n pres"
},
{
"path": "config/listImports.ts",
"chars": 691,
"preview": "/**\n * used via e.g.\n *\n * ```sh\n * node --experimental-transform-types --no-warnings --conditions 'react-server' config"
},
{
"path": "config/madge.ts",
"chars": 943,
"preview": "import { join } from \"node:path\";\n\nimport * as madgePkg from \"madge\";\nconst madge = madgePkg.default;\nprocess.env.DEBUG "
},
{
"path": "config/precheck.ts",
"chars": 416,
"preview": "import lockfile from \"../package-lock.json\" with { type: \"json\" };\nconst { lockfileVersion } = lockfile;\n\nconst expected"
},
{
"path": "config/prepareDist.ts",
"chars": 2778,
"preview": "// The Apollo Client source that is published to npm is located in the\n// \"dist\" directory. This utility script is calle"
},
{
"path": "config/preserveTsIgnore.ts",
"chars": 1622,
"preview": "/**\n * TypeScript removes normal comments when it creates declaration files.\n *\n * That means that `// @ts-ignore` comme"
},
{
"path": "config/prettier/format-jsdoc.js",
"chars": 2876,
"preview": "/** @import { TSESTree as AST } from '@typescript-eslint/types' */\n/** @import { Plugin, Printer } from 'prettier' */\n\ni"
},
{
"path": "config/prettier/format-mdx3.js",
"chars": 4526,
"preview": "/** @import { Plugin } from 'prettier' */\n\nimport * as prettier from \"prettier\";\nimport markdown from \"prettier/plugins/"
},
{
"path": "config/prettier/test.ts",
"chars": 316,
"preview": "import * as prettier from \"prettier\";\nconst code = `\n\\`\\`\\`ts\nconst client = new ApolloClient({\n link: new HttpLink({ /"
},
{
"path": "config/processInvariants.ts",
"chars": 12390,
"preview": "import * as fs from \"fs\";\nimport { join as osPathJoin, posix } from \"path\";\n\nimport type { ExpressionKind } from \"ast-ty"
},
{
"path": "config/react-compiler.ts",
"chars": 5940,
"preview": "import { readFileSync } from \"node:fs\";\nimport { cp, mkdir } from \"node:fs/promises\";\nimport { dirname, format, join, pa"
},
{
"path": "config/schema.package.json.ts",
"chars": 1621986,
"preview": "/**\n * This file was automatically generated by json-schema-to-typescript\n * based on https://json.schemastore.org/packa"
},
{
"path": "config/size-limit/index.js",
"chars": 1281,
"preview": "// @ts-check\n\nimport { mkdir, symlink } from \"node:fs/promises\";\nimport { join } from \"node:path\";\n\n/**\n * @typedef Conf"
},
{
"path": "config/size-limit/package.json",
"chars": 143,
"preview": "{\n \"name\": \"size-limit-apollo-plugin\",\n \"type\": \"module\",\n \"exports\": {\n \".\": \"./index.js\",\n \"./package.json\": "
},
{
"path": "config/tsconfig.json",
"chars": 355,
"preview": "{\n \"compilerOptions\": {\n \"composite\": true,\n \"outDir\": \".ignore\",\n \"target\": \"esnext\",\n \"module\": \"nodenext"
},
{
"path": "config/verifySourceMaps.ts",
"chars": 2660,
"preview": "import * as assert from \"node:assert\";\nimport { glob, readFile } from \"node:fs/promises\";\nimport { join } from \"node:pat"
},
{
"path": "config/version.ts",
"chars": 2186,
"preview": "import assert from \"node:assert\";\nimport { createRequire } from \"node:module\";\nimport path from \"node:path\";\n\nimport { v"
},
{
"path": "docs/README.md",
"chars": 1119,
"preview": "# Documentation\n\nThis is the documentation **source** for this repository.\n\nThe **deployed** version of the documentatio"
},
{
"path": "docs/shared/MdxProvidedComponents.ts",
"chars": 6568,
"preview": "import type * as React from \"react\";\n\ndeclare module \"react\" {\n namespace React {\n interface HTMLAttributes<T> {\n "
},
{
"path": "docs/source/_sidebar.yaml",
"chars": 8216,
"preview": "switcher:\n heading: \"Apollo Client (Web)\"\n versions:\n - label: v4\n latest: true\n href: ./\n - label: v3"
},
{
"path": "docs/source/api/cache/InMemoryCache.mdx",
"chars": 25088,
"preview": "---\ntitle: class InMemoryCache\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared"
},
{
"path": "docs/source/api/core/ApolloClient.mdx",
"chars": 4268,
"preview": "---\ntitle: class ApolloClient\ndescription: API reference\norder: 11\n---\n\n{/* @import {MDXProvidedComponents} from '../../"
},
{
"path": "docs/source/api/core/ObservableQuery.mdx",
"chars": 5530,
"preview": "---\ntitle: ObservableQuery\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared/Mdx"
},
{
"path": "docs/source/api/errors/CombinedGraphQLErrors.mdx",
"chars": 1781,
"preview": "---\ntitle: CombinedGraphQLErrors\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shar"
},
{
"path": "docs/source/api/errors/CombinedProtocolErrors.mdx",
"chars": 1792,
"preview": "---\ntitle: CombinedProtocolErrors\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../sha"
},
{
"path": "docs/source/api/errors/LinkError.mdx",
"chars": 1702,
"preview": "---\ntitle: LinkError\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared/MdxProvid"
},
{
"path": "docs/source/api/errors/LocalStateError.mdx",
"chars": 1166,
"preview": "---\ntitle: LocalStateError\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared/Mdx"
},
{
"path": "docs/source/api/errors/ServerError.mdx",
"chars": 969,
"preview": "---\ntitle: ServerError\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared/MdxProv"
},
{
"path": "docs/source/api/errors/ServerParseError.mdx",
"chars": 1103,
"preview": "---\ntitle: ServerParseError\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared/Md"
},
{
"path": "docs/source/api/errors/UnconventionalError.mdx",
"chars": 1041,
"preview": "---\ntitle: UnconventionalError\ndescription: API reference\n---\n\n{/* * @import {MDXProvidedComponents} from '../../../shar"
},
{
"path": "docs/source/api/link/apollo-link-base-batch-http.mdx",
"chars": 857,
"preview": "---\ntitle: BaseBatchHttpLink\ndescription: Batch multiple operations into a single HTTP request\n---\n\n<DocBlock\n canonica"
},
{
"path": "docs/source/api/link/apollo-link-base-http.mdx",
"chars": 947,
"preview": "---\ntitle: BaseHttpLink\ndescription: Get GraphQL results over a network using HTTP fetch\n---\n\n<DocBlock\n canonicalRefer"
},
{
"path": "docs/source/api/link/apollo-link-batch-http.mdx",
"chars": 2160,
"preview": "---\ntitle: BatchHttpLink\ndescription: Batch multiple operations into a single HTTP request\n---\n\n<DocBlock\n canonicalRef"
},
{
"path": "docs/source/api/link/apollo-link-batch.mdx",
"chars": 491,
"preview": "---\ntitle: BatchLink\ndescription: Core batching functionality for grouping multiple GraphQL operations\n---\n\n<DocBlock\n "
},
{
"path": "docs/source/api/link/apollo-link-client-awareness.mdx",
"chars": 3287,
"preview": "---\ntitle: ClientAwarenessLink\ndescription: API reference\n---\n\n<DocBlock\n canonicalReference=\"@apollo/client/link/clien"
},
{
"path": "docs/source/api/link/apollo-link-context.mdx",
"chars": 2844,
"preview": "---\ntitle: SetContextLink\ndescription: Easily set a context on your operation, which is used by other links further down"
},
{
"path": "docs/source/api/link/apollo-link-error.mdx",
"chars": 823,
"preview": "---\ntitle: ErrorLink\ndescription: Handle and inspect errors in your GraphQL network stack.\n---\n\n<DocBlock\n canonicalRef"
},
{
"path": "docs/source/api/link/apollo-link-http.mdx",
"chars": 1309,
"preview": "---\ntitle: HttpLink\ndescription: Get GraphQL results over a network using HTTP fetch.\n---\n\n<DocBlock\n canonicalReferenc"
},
{
"path": "docs/source/api/link/apollo-link-persisted-queries.mdx",
"chars": 3401,
"preview": "---\ntitle: PersistedQueryLink\ndescription: Secure your graph while minimizing request latency\n---\n\n<DocBlock\n canonical"
},
{
"path": "docs/source/api/link/apollo-link-remove-typename.mdx",
"chars": 7436,
"preview": "---\ntitle: RemoveTypenameFromVariablesLink\ndescription: Automatically remove __typename fields from variables.\n---\n\n<Doc"
},
{
"path": "docs/source/api/link/apollo-link-retry.mdx",
"chars": 2835,
"preview": "---\ntitle: RetryLink\ndescription: Attempt an operation multiple times if it fails due to network or server errors.\n---\n\n"
},
{
"path": "docs/source/api/link/apollo-link-schema.mdx",
"chars": 2144,
"preview": "---\ntitle: SchemaLink\ndescription: Assists with mocking and server-side rendering\n---\n\n<DocBlock\n canonicalReference=\"@"
},
{
"path": "docs/source/api/link/apollo-link-subscriptions.mdx",
"chars": 1968,
"preview": "---\ntitle: GraphQLWsLink\ndescription: Execute subscriptions (or other operations) over WebSocket with the graphql-ws lib"
},
{
"path": "docs/source/api/link/apollo-link-ws.mdx",
"chars": 1366,
"preview": "---\ntitle: WebSocketLink\ndescription: Execute subscriptions (or other operations) over WebSocket with the subscriptions-"
},
{
"path": "docs/source/api/link/apollo-link.mdx",
"chars": 2505,
"preview": "---\ntitle: ApolloLink\ndescription: API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../shared/MdxProvi"
},
{
"path": "docs/source/api/link/community-links.mdx",
"chars": 6962,
"preview": "---\ntitle: Community links\n---\n\nThank you to all the Apollo community members who have contributed custom Apollo links! "
},
{
"path": "docs/source/api/link/introduction.mdx",
"chars": 20263,
"preview": "---\ntitle: Apollo Link overview\ndescription: Customize Apollo Client's data flow\n---\n\nThe **Apollo Link** library helps "
},
{
"path": "docs/source/api/react/ApolloProvider.mdx",
"chars": 1033,
"preview": "---\ntitle: ApolloProvider\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../"
},
{
"path": "docs/source/api/react/hooks-experimental.mdx",
"chars": 253,
"preview": "---\ntitle: Hooks (experimental)\ndescription: Apollo Client experimental react hooks API reference\n---\n\nThe latest minor "
},
{
"path": "docs/source/api/react/hooks.mdx",
"chars": 304,
"preview": "---\ntitle: Hooks\ndescription: Apollo Client react hooks API reference\nminVersion: 3.0.0\n---\n\n{/* @import {MDXProvidedCom"
},
{
"path": "docs/source/api/react/preloading.mdx",
"chars": 283,
"preview": "---\ntitle: createQueryPreloader\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '"
},
{
"path": "docs/source/api/react/skipToken.mdx",
"chars": 2768,
"preview": "---\ntitle: skipToken\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../sh"
},
{
"path": "docs/source/api/react/ssr.mdx",
"chars": 2576,
"preview": "---\ntitle: SSR\ndescription: Apollo Client React server side rendering API\n---\n\n## Installation\n\nApollo Client >= 3 inclu"
},
{
"path": "docs/source/api/react/testing.mdx",
"chars": 2939,
"preview": "---\ntitle: MockProvider\ndescription: Apollo Client API reference\n---\n\n> For more guidance on running tests with `MockedP"
},
{
"path": "docs/source/api/react/useApolloClient.mdx",
"chars": 273,
"preview": "---\ntitle: useApolloClient\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../.."
},
{
"path": "docs/source/api/react/useBackgroundQuery.mdx",
"chars": 1426,
"preview": "---\ntitle: useBackgroundQuery\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '.."
},
{
"path": "docs/source/api/react/useFragment.mdx",
"chars": 296,
"preview": "---\ntitle: useFragment\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../"
},
{
"path": "docs/source/api/react/useLazyQuery.mdx",
"chars": 1124,
"preview": "---\ntitle: useLazyQuery\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../.."
},
{
"path": "docs/source/api/react/useLoadableQuery.mdx",
"chars": 1576,
"preview": "---\ntitle: useLoadableQuery\ndescription: Apollo Client API reference\n---\n\n<FunctionDetails\n canonicalReference=\"@apollo"
},
{
"path": "docs/source/api/react/useMutation.mdx",
"chars": 1536,
"preview": "---\ntitle: useMutation\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../"
},
{
"path": "docs/source/api/react/useQuery.mdx",
"chars": 287,
"preview": "---\ntitle: useQuery\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../../sha"
},
{
"path": "docs/source/api/react/useQueryRefHandlers.mdx",
"chars": 281,
"preview": "---\ntitle: useQueryRefHandlers\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '."
},
{
"path": "docs/source/api/react/useReactiveVar.mdx",
"chars": 271,
"preview": "---\ntitle: useReactiveVar\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../"
},
{
"path": "docs/source/api/react/useReadQuery.mdx",
"chars": 299,
"preview": "---\ntitle: useReadQuery\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../../.."
},
{
"path": "docs/source/api/react/useSubscription.mdx",
"chars": 273,
"preview": "---\ntitle: useSubscription\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../.."
},
{
"path": "docs/source/api/react/useSuspenseQuery.mdx",
"chars": 311,
"preview": "---\ntitle: useSuspenseQuery\ndescription: Apollo Client API reference\n---\n\n{/* @import {MDXProvidedComponents} from '../."
},
{
"path": "docs/source/caching/advanced-topics.mdx",
"chars": 15981,
"preview": "---\ntitle: Advanced topics on caching in Apollo Client\n---\n\nThis article describes special cases and considerations when"
},
{
"path": "docs/source/caching/cache-configuration.mdx",
"chars": 14029,
"preview": "---\ntitle: Configuring the Apollo Client cache\n---\n\nThis article describes cache setup and configuration. To learn how t"
},
{
"path": "docs/source/caching/cache-field-behavior.mdx",
"chars": 29332,
"preview": "---\ntitle: Customizing the behavior of cached fields\n---\n\nYou can customize how a particular field in your Apollo Client"
},
{
"path": "docs/source/caching/cache-interaction.mdx",
"chars": 27151,
"preview": "---\ntitle: Reading and writing data to the cache\n---\n\n{/* @import {MDXProvidedComponents} from '../../shared/MdxProvided"
},
{
"path": "docs/source/caching/garbage-collection.mdx",
"chars": 5113,
"preview": "---\ntitle: Garbage collection and cache eviction\n---\n\nApollo Client 3 enables you to selectively remove cached data that"
},
{
"path": "docs/source/caching/memory-management.mdx",
"chars": 4900,
"preview": "---\ntitle: Memory management\nsubtitle: Learn how to choose and set custom cache sizes\ndescription: Learn how to choose a"
},
{
"path": "docs/source/caching/overview.mdx",
"chars": 8687,
"preview": "---\ntitle: Caching in Apollo Client\ndescription: Overview\n---\n\nApollo Client stores the results of your GraphQL queries "
},
{
"path": "docs/source/data/defer.mdx",
"chars": 9519,
"preview": "---\ntitle: \"Using the @defer directive in Apollo Client\"\ndescription: Receive query response data incrementally\n---\n\nThe"
},
{
"path": "docs/source/data/directives.mdx",
"chars": 9713,
"preview": "---\ntitle: \"Using GraphQL directives in Apollo Client\"\ndescription: Configure GraphQL fields and fragments\n---\n\nA direct"
},
{
"path": "docs/source/data/document-transforms.mdx",
"chars": 27670,
"preview": "---\ntitle: Document transforms\ndescription: Make custom modifications to your GraphQL documents\n---\n\n{/* @import {MDXPro"
},
{
"path": "docs/source/data/error-handling.mdx",
"chars": 19608,
"preview": "---\ntitle: Handling operation errors\ndescription: Learn how to manage errors in your application\n---\n\n{/* * @import {MDX"
},
{
"path": "docs/source/data/file-uploads.mdx",
"chars": 927,
"preview": "---\ntitle: File uploads\ndescription: Enabling file uploads in Apollo Client\n---\n\nApollo Client doesn't support a file up"
},
{
"path": "docs/source/data/fragments.mdx",
"chars": 60454,
"preview": "---\ntitle: Fragments\ndescription: Share fields between operations\n---\n\nA [GraphQL fragment](http://graphql.org/learn/que"
},
{
"path": "docs/source/data/mutations.mdx",
"chars": 21975,
"preview": "---\ntitle: Mutations in Apollo Client\ndescription: Modify data with the useMutation hook\n---\n\n{/* @import {MDXProvidedCo"
},
{
"path": "docs/source/data/operation-best-practices.mdx",
"chars": 6893,
"preview": "---\ntitle: GraphQL query best practices\ndescription: Operation naming, GraphQL variables, and more\n---\n\nWhen creating qu"
},
{
"path": "docs/source/data/persisted-queries.mdx",
"chars": 12661,
"preview": "---\ntitle: Persisted queries\ndescription: Secure your graph while minimizing request latency\nredirectFrom:\n - /react/ap"
},
{
"path": "docs/source/data/queries.mdx",
"chars": 31838,
"preview": "---\ntitle: Queries\ndescription: Fetch data with the useQuery hook\n---\n\n{/* @import {MDXProvidedComponents} from '../../s"
},
{
"path": "docs/source/data/refetching.mdx",
"chars": 12480,
"preview": "---\ntitle: Refetching queries in Apollo Client\n---\n\n{/* @import {MDXProvidedComponents} from '../../shared/MdxProvidedCo"
},
{
"path": "docs/source/data/subscriptions.mdx",
"chars": 22555,
"preview": "---\ntitle: Subscriptions\ndescription: Get real-time updates from your GraphQL server\n---\n\n{/* @import {MDXProvidedCompon"
},
{
"path": "docs/source/data/suspense.mdx",
"chars": 36727,
"preview": "---\ntitle: Suspense\ndescription: Use React 18 Suspense features with Apollo Client\n---\n\n\"Suspense\" is generally used to "
}
]
// ... and 736 more files (download for full content)
About this extraction
This page contains the full source code of the apollographql/apollo-client GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 936 files (11.5 MB), approximately 3.1M tokens, and a symbol index with 3557 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.