@depup/apollo__client 4.1.6-depup.0

package/core/index.d.ts

@@ -0,0 +1,31 @@
+export type { ApolloClientOptions, ApolloQueryResult, DefaultOptions, DevtoolsOptions, MutateResult, MutationOptions, QueryOptions, RefetchQueriesOptions, RefetchQueriesResult, SubscribeToMoreOptions, SubscriptionOptions, WatchQueryOptions, } from "./deprecated.js";
+export { ApolloClient } from "./ApolloClient.js";
+export { ObservableQuery } from "./ObservableQuery.js";
+export type { ErrorPolicy, FetchPolicy, MutationFetchPolicy, RefetchWritePolicy, SubscribeToMoreFunction, SubscribeToMoreUpdateQueryFn, UpdateQueryMapFn, UpdateQueryOptions, WatchQueryFetchPolicy, } from "./watchQueryOptions.js";
+export { NetworkStatus } from "./networkStatus.js";
+export type { DataState, DataValue, DefaultContext, ErrorLike, GetDataState, InternalRefetchQueriesInclude, InternalRefetchQueriesMap, InternalRefetchQueriesOptions, InternalRefetchQueriesResult, InternalRefetchQueryDescriptor, MutationQueryReducer, MutationQueryReducersMap, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, RefetchQueriesInclude, RefetchQueriesPromiseResults, RefetchQueryDescriptor, SubscriptionObservable, TypedDocumentNode, TypeOverrides, } from "./types.js";
+export { CombinedGraphQLErrors, CombinedProtocolErrors, LinkError, LocalStateError, ServerError, ServerParseError, UnconventionalError, } from "@apollo/client/errors";
+export type { ApolloReducerConfig, Cache, DiffQueryAgainstStoreOptions, FieldFunctionOptions, FieldMergeFunction, FieldPolicy, FieldReadFunction, IdGetter, IdGetterObj, InMemoryCacheConfig, MergeInfo, MergeTree, NormalizedCache, NormalizedCacheObject, OptimisticStoreItem, PossibleTypesMap, ReactiveVar, ReadMergeModifyContext, ReadQueryOptions, StoreValue, Transaction, TypePolicies, TypePolicy, WatchFragmentOptions, WatchFragmentResult, } from "@apollo/client/cache";
+export { ApolloCache, defaultDataIdFromObject, InMemoryCache, makeVar, MissingFieldError, } from "@apollo/client/cache";
+export { ApolloLink, concat, empty, execute, from, split, } from "@apollo/client/link";
+export type { ApolloPayloadResult, DocumentNode, FetchResult, GraphQLRequest, Operation, RequestHandler, } from "@apollo/client/link";
+export { checkFetcher, createHttpLink, createSignalIfSupported, defaultPrinter, fallbackHttpConfig, HttpLink, parseAndCheckHttpResponse, rewriteURIForGET, selectHttpOptionsAndBody, selectHttpOptionsAndBodyInternal, selectURI, } from "@apollo/client/link/http";
+export type { FragmentType, MaybeMasked, Unmasked, } from "@apollo/client/masking";
+export type { DocumentTransformCacheKey, Reference, StoreObject, } from "@apollo/client/utilities";
+export { DocumentTransform, 
+/** @deprecated Please import `isNetworkRequestSettled` from `@apollo/client/utilities`. */
+isNetworkRequestSettled, isReference, Observable, } from "@apollo/client/utilities";
+export { setVerbosity as setLogVerbosity } from "@apollo/client/utilities/invariant";
+export { disableExperimentalFragmentVariables, disableFragmentWarnings, enableExperimentalFragmentVariables, gql, resetCaches, } from "graphql-tag";
+export { build, version } from "../version.js";
+import type { QueryManager } from "./QueryManager.js";
+import type { NextFetchPolicyContext } from "./watchQueryOptions.js";
+/**
+* @internal
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+export declare namespace InternalTypes {
+    export type { NextFetchPolicyContext, QueryManager };
+}
+//# sourceMappingURL=index.d.ts.map

package/core/index.js

@@ -0,0 +1,34 @@
+/* Core */
+export { ApolloClient } from "./ApolloClient.js";
+export { ObservableQuery } from "./ObservableQuery.js";
+export { NetworkStatus } from "./networkStatus.js";
+export { CombinedGraphQLErrors, CombinedProtocolErrors, LinkError, LocalStateError, ServerError, ServerParseError, UnconventionalError, } from "@apollo/client/errors";
+export { ApolloCache, defaultDataIdFromObject, InMemoryCache, makeVar, MissingFieldError, } from "@apollo/client/cache";
+/* Link */
+export { ApolloLink, concat, empty, execute, from, split, } from "@apollo/client/link";
+export { checkFetcher, createHttpLink, createSignalIfSupported, defaultPrinter, fallbackHttpConfig, HttpLink, parseAndCheckHttpResponse, rewriteURIForGET, selectHttpOptionsAndBody, 
+// TODO remove: needed by @apollo/client/link/batch-http but not public
+selectHttpOptionsAndBodyInternal, selectURI, } from "@apollo/client/link/http";
+export { DocumentTransform, 
+/** @deprecated Please import `isNetworkRequestSettled` from `@apollo/client/utilities`. */
+isNetworkRequestSettled, isReference, Observable, } from "@apollo/client/utilities";
+/* Supporting */
+// The verbosity of invariant.{log,warn,error} can be controlled globally
+// by passing "log", "warn", "error", or "silent" to setVerbosity ("log" is the default).
+// Note that all invariant.* logging is hidden in production.
+export { setVerbosity as setLogVerbosity } from "@apollo/client/utilities/invariant";
+// Note that importing `gql` by itself, then destructuring
+// additional properties separately before exporting, is intentional.
+// Due to the way the `graphql-tag` library is setup, certain bundlers
+// can't find the properties added to the exported `gql` function without
+// additional guidance (e.g. Rollup - see
+// https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module).
+// Instead of having people that are using bundlers with `@apollo/client` add
+// extra bundler config to help `graphql-tag` exports be found (which would be
+// awkward since they aren't importing `graphql-tag` themselves), this
+// workaround of pulling the extra properties off the `gql` function,
+// then re-exporting them separately, helps keeps bundlers happy without any
+// additional config changes.
+export { disableExperimentalFragmentVariables, disableFragmentWarnings, enableExperimentalFragmentVariables, gql, resetCaches, } from "graphql-tag";
+export { build, version } from "../version.js";
+//# sourceMappingURL=index.js.map

package/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,UAAU;AAgBV,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAYvD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAyBnD,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,SAAS,EACT,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAiC/B,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,aAAa,EACb,OAAO,EACP,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAE9B,UAAU;AAEV,OAAO,EACL,UAAU,EACV,MAAM,EACN,KAAK,EACL,OAAO,EACP,IAAI,EACJ,KAAK,GACN,MAAM,qBAAqB,CAAC;AAU7B,OAAO,EACL,YAAY,EACZ,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,QAAQ,EACR,yBAAyB,EACzB,gBAAgB,EAChB,wBAAwB;AACxB,uEAAuE;AACvE,gCAAgC,EAChC,SAAS,GACV,MAAM,0BAA0B,CAAC;AAgBlC,OAAO,EACL,iBAAiB;AACjB,2FAA2F;AAC3F,uBAAuB,EACvB,WAAW,EACX,UAAU,GACX,MAAM,0BAA0B,CAAC;AAElC,gBAAgB;AAEhB,yEAAyE;AACzE,yFAAyF;AACzF,6DAA6D;AAC7D,OAAO,EAAE,YAAY,IAAI,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAErF,0DAA0D;AAC1D,qEAAqE;AACrE,sEAAsE;AACtE,yEAAyE;AACzE,yCAAyC;AACzC,wEAAwE;AACxE,6EAA6E;AAC7E,8EAA8E;AAC9E,sEAAsE;AACtE,qEAAqE;AACrE,4EAA4E;AAC5E,6BAA6B;AAC7B,OAAO,EACL,oCAAoC,EACpC,uBAAuB,EACvB,mCAAmC,EACnC,GAAG,EACH,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC","sourcesContent":["/* Core */\n\nexport type {\n  ApolloClientOptions,\n  ApolloQueryResult,\n  DefaultOptions,\n  DevtoolsOptions,\n  MutateResult,\n  MutationOptions,\n  QueryOptions,\n  RefetchQueriesOptions,\n  RefetchQueriesResult,\n  SubscribeToMoreOptions,\n  SubscriptionOptions,\n  WatchQueryOptions,\n} from \"./deprecated.js\";\nexport { ApolloClient } from \"./ApolloClient.js\";\nexport { ObservableQuery } from \"./ObservableQuery.js\";\nexport type {\n  ErrorPolicy,\n  FetchPolicy,\n  MutationFetchPolicy,\n  RefetchWritePolicy,\n  SubscribeToMoreFunction,\n  SubscribeToMoreUpdateQueryFn,\n  UpdateQueryMapFn,\n  UpdateQueryOptions,\n  WatchQueryFetchPolicy,\n} from \"./watchQueryOptions.js\";\nexport { NetworkStatus } from \"./networkStatus.js\";\nexport type {\n  DataState,\n  DataValue,\n  DefaultContext,\n  ErrorLike,\n  GetDataState,\n  InternalRefetchQueriesInclude,\n  InternalRefetchQueriesMap,\n  InternalRefetchQueriesOptions,\n  InternalRefetchQueriesResult,\n  InternalRefetchQueryDescriptor,\n  MutationQueryReducer,\n  MutationQueryReducersMap,\n  MutationUpdaterFunction,\n  NormalizedExecutionResult,\n  OnQueryUpdated,\n  OperationVariables,\n  RefetchQueriesInclude,\n  RefetchQueriesPromiseResults,\n  RefetchQueryDescriptor,\n  SubscriptionObservable,\n  TypedDocumentNode,\n  TypeOverrides,\n} from \"./types.js\";\nexport {\n  CombinedGraphQLErrors,\n  CombinedProtocolErrors,\n  LinkError,\n  LocalStateError,\n  ServerError,\n  ServerParseError,\n  UnconventionalError,\n} from \"@apollo/client/errors\";\n/* Cache */\n\nexport type {\n  ApolloReducerConfig,\n  Cache,\n  DiffQueryAgainstStoreOptions,\n  FieldFunctionOptions,\n  FieldMergeFunction,\n  FieldPolicy,\n  FieldReadFunction,\n  IdGetter,\n  IdGetterObj,\n  InMemoryCacheConfig,\n  MergeInfo,\n  MergeTree,\n  NormalizedCache,\n  NormalizedCacheObject,\n  OptimisticStoreItem,\n  PossibleTypesMap,\n  ReactiveVar,\n  ReadMergeModifyContext,\n  ReadQueryOptions,\n  StoreValue,\n  // All the exports (types) from ../cache, minus cacheSlot,\n  // which we want to keep semi-private.\n  Transaction,\n  TypePolicies,\n  TypePolicy,\n  WatchFragmentOptions,\n  WatchFragmentResult,\n} from \"@apollo/client/cache\";\n\nexport {\n  ApolloCache,\n  defaultDataIdFromObject,\n  InMemoryCache,\n  makeVar,\n  MissingFieldError,\n} from \"@apollo/client/cache\";\n\n/* Link */\n\nexport {\n  ApolloLink,\n  concat,\n  empty,\n  execute,\n  from,\n  split,\n} from \"@apollo/client/link\";\nexport type {\n  ApolloPayloadResult,\n  DocumentNode,\n  FetchResult,\n  GraphQLRequest,\n  Operation,\n  RequestHandler,\n} from \"@apollo/client/link\";\n\nexport {\n  checkFetcher,\n  createHttpLink,\n  createSignalIfSupported,\n  defaultPrinter,\n  fallbackHttpConfig,\n  HttpLink,\n  parseAndCheckHttpResponse,\n  rewriteURIForGET,\n  selectHttpOptionsAndBody,\n  // TODO remove: needed by @apollo/client/link/batch-http but not public\n  selectHttpOptionsAndBodyInternal,\n  selectURI,\n} from \"@apollo/client/link/http\";\n\n/* Masking */\nexport type {\n  FragmentType,\n  MaybeMasked,\n  Unmasked,\n} from \"@apollo/client/masking\";\n\n/* Utilities */\n\nexport type {\n  DocumentTransformCacheKey,\n  Reference,\n  StoreObject,\n} from \"@apollo/client/utilities\";\nexport {\n  DocumentTransform,\n  /** @deprecated Please import `isNetworkRequestSettled` from `@apollo/client/utilities`. */\n  isNetworkRequestSettled,\n  isReference,\n  Observable,\n} from \"@apollo/client/utilities\";\n\n/* Supporting */\n\n// The verbosity of invariant.{log,warn,error} can be controlled globally\n// by passing \"log\", \"warn\", \"error\", or \"silent\" to setVerbosity (\"log\" is the default).\n// Note that all invariant.* logging is hidden in production.\nexport { setVerbosity as setLogVerbosity } from \"@apollo/client/utilities/invariant\";\n\n// Note that importing `gql` by itself, then destructuring\n// additional properties separately before exporting, is intentional.\n// Due to the way the `graphql-tag` library is setup, certain bundlers\n// can't find the properties added to the exported `gql` function without\n// additional guidance (e.g. Rollup - see\n// https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module).\n// Instead of having people that are using bundlers with `@apollo/client` add\n// extra bundler config to help `graphql-tag` exports be found (which would be\n// awkward since they aren't importing `graphql-tag` themselves), this\n// workaround of pulling the extra properties off the `gql` function,\n// then re-exporting them separately, helps keeps bundlers happy without any\n// additional config changes.\nexport {\n  disableExperimentalFragmentVariables,\n  disableFragmentWarnings,\n  enableExperimentalFragmentVariables,\n  gql,\n  resetCaches,\n} from \"graphql-tag\";\nexport { build, version } from \"../version.js\";\n\n// internal types\nimport type { QueryManager } from \"./QueryManager.js\";\nimport type { NextFetchPolicyContext } from \"./watchQueryOptions.js\";\n/** @internal */\nexport declare namespace InternalTypes {\n  export type { NextFetchPolicyContext, QueryManager };\n}\n"]}

package/core/networkStatus.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The current status of a query’s execution in our system.
+ */
+export declare enum NetworkStatus {
+    /**
+     * The query has never been run before and the query is now currently running. A query will still
+     * have this network status even if a partial data result was returned from the cache, but a
+     * query was dispatched anyway.
+     */
+    loading = 1,
+    /**
+     * If `setVariables` was called and a query was fired because of that then the network status
+     * will be `setVariables` until the result of that query comes back.
+     */
+    setVariables = 2,
+    /**
+     * Indicates that `fetchMore` was called on this query and that the query created is currently in
+     * flight.
+     */
+    fetchMore = 3,
+    /**
+     * Similar to the `setVariables` network status. It means that `refetch` was called on a query
+     * and the refetch request is currently in flight.
+     */
+    refetch = 4,
+    /**
+     * Indicates that a polling query is currently in flight. So for example if you are polling a
+     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever
+     * a poll request has been sent but not resolved.
+     */
+    poll = 6,
+    /**
+     * No request is in flight for this query, and no errors happened. Everything is OK.
+     */
+    ready = 7,
+    /**
+     * No request is in flight for this query, but one or more errors were detected.
+     */
+    error = 8,
+    /**
+     * Indicates that a `@defer` query has received at least the first chunk of
+     * the result but the full result has not yet been fully streamed to the
+     * client.
+     */
+    streaming = 9
+}
+//# sourceMappingURL=networkStatus.d.ts.map

package/core/networkStatus.js

@@ -0,0 +1,48 @@
+/**
+ * The current status of a query’s execution in our system.
+ */
+export var NetworkStatus;
+(function (NetworkStatus) {
+    /**
+     * The query has never been run before and the query is now currently running. A query will still
+     * have this network status even if a partial data result was returned from the cache, but a
+     * query was dispatched anyway.
+     */
+    NetworkStatus[NetworkStatus["loading"] = 1] = "loading";
+    /**
+     * If `setVariables` was called and a query was fired because of that then the network status
+     * will be `setVariables` until the result of that query comes back.
+     */
+    NetworkStatus[NetworkStatus["setVariables"] = 2] = "setVariables";
+    /**
+     * Indicates that `fetchMore` was called on this query and that the query created is currently in
+     * flight.
+     */
+    NetworkStatus[NetworkStatus["fetchMore"] = 3] = "fetchMore";
+    /**
+     * Similar to the `setVariables` network status. It means that `refetch` was called on a query
+     * and the refetch request is currently in flight.
+     */
+    NetworkStatus[NetworkStatus["refetch"] = 4] = "refetch";
+    /**
+     * Indicates that a polling query is currently in flight. So for example if you are polling a
+     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever
+     * a poll request has been sent but not resolved.
+     */
+    NetworkStatus[NetworkStatus["poll"] = 6] = "poll";
+    /**
+     * No request is in flight for this query, and no errors happened. Everything is OK.
+     */
+    NetworkStatus[NetworkStatus["ready"] = 7] = "ready";
+    /**
+     * No request is in flight for this query, but one or more errors were detected.
+     */
+    NetworkStatus[NetworkStatus["error"] = 8] = "error";
+    /**
+     * Indicates that a `@defer` query has received at least the first chunk of
+     * the result but the full result has not yet been fully streamed to the
+     * client.
+     */
+    NetworkStatus[NetworkStatus["streaming"] = 9] = "streaming";
+})(NetworkStatus || (NetworkStatus = {}));
+//# sourceMappingURL=networkStatus.js.map

package/core/networkStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatus.js","sourceRoot":"","sources":["../../src/core/networkStatus.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,aAiDX;AAjDD,WAAY,aAAa;IACvB;;;;OAIG;IACH,uDAAW,CAAA;IAEX;;;OAGG;IACH,iEAAgB,CAAA;IAEhB;;;OAGG;IACH,2DAAa,CAAA;IAEb;;;OAGG;IACH,uDAAW,CAAA;IAEX;;;;OAIG;IACH,iDAAQ,CAAA;IAER;;OAEG;IACH,mDAAS,CAAA;IAET;;OAEG;IACH,mDAAS,CAAA;IAET;;;;OAIG;IACH,2DAAa,CAAA;AACf,CAAC,EAjDW,aAAa,KAAb,aAAa,QAiDxB","sourcesContent":["/**\n * The current status of a query’s execution in our system.\n */\nexport enum NetworkStatus {\n  /**\n   * The query has never been run before and the query is now currently running. A query will still\n   * have this network status even if a partial data result was returned from the cache, but a\n   * query was dispatched anyway.\n   */\n  loading = 1,\n\n  /**\n   * If `setVariables` was called and a query was fired because of that then the network status\n   * will be `setVariables` until the result of that query comes back.\n   */\n  setVariables = 2,\n\n  /**\n   * Indicates that `fetchMore` was called on this query and that the query created is currently in\n   * flight.\n   */\n  fetchMore = 3,\n\n  /**\n   * Similar to the `setVariables` network status. It means that `refetch` was called on a query\n   * and the refetch request is currently in flight.\n   */\n  refetch = 4,\n\n  /**\n   * Indicates that a polling query is currently in flight. So for example if you are polling a\n   * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever\n   * a poll request has been sent but not resolved.\n   */\n  poll = 6,\n\n  /**\n   * No request is in flight for this query, and no errors happened. Everything is OK.\n   */\n  ready = 7,\n\n  /**\n   * No request is in flight for this query, but one or more errors were detected.\n   */\n  error = 8,\n\n  /**\n   * Indicates that a `@defer` query has received at least the first chunk of\n   * the result but the full result has not yet been fully streamed to the\n   * client.\n   */\n  streaming = 9,\n}\n"]}

package/core/types.d.ts

@@ -0,0 +1,327 @@
+import type { DocumentNode, FormattedExecutionResult } from "graphql";
+import type { NextNotification, Observable, ObservableNotification } from "rxjs";
+import type { ApolloCache } from "@apollo/client/cache";
+import type { Cache } from "@apollo/client/cache";
+import type { ClientAwarenessLink } from "@apollo/client/link/client-awareness";
+import type { Unmasked } from "@apollo/client/masking";
+import type { DeepPartial, HKT } from "@apollo/client/utilities";
+import type { ApplyHKTImplementationWithDefault, IsAny } from "@apollo/client/utilities/internal";
+import type { ApolloClient } from "./ApolloClient.js";
+import type { ObservableQuery } from "./ObservableQuery.js";
+export type { TypedDocumentNode } from "@graphql-typed-document-node/core";
+export interface TypeOverrides {
+}
+declare namespace OverridableTypes {
+    interface Defaults {
+        Complete: Complete;
+        Streaming: Streaming;
+        Partial: Partial;
+    }
+    interface Complete extends HKT {
+        arg1: unknown;
+        return: this["arg1"];
+    }
+    interface Streaming extends HKT {
+        arg1: unknown;
+        return: this["arg1"];
+    }
+    interface Partial extends HKT {
+        arg1: unknown;
+        return: DeepPartial<this["arg1"]>;
+    }
+}
+export declare namespace DataValue {
+    /**
+     * Returns a representation of `TData` in it's "complete" state.
+     *
+     * @defaultValue `TData` if no overrides are provided.
+     *
+     * @example
+     * You can override this type globally - this example shows how to override it
+     * with `DeepPartial<TData>`:
+     *
+     * ```ts
+     * import { HKT, DeepPartial } from "@apollo/client/utilities";
+     *
+     * type CompleteOverride<TData> =
+     *   TData extends { _complete?: infer _Complete } ? _Complete : TData;
+     *
+     * interface CompleteOverrideHKT extends HKT {
+     *   return: CompleteOverride<this["arg1"]>;
+     * }
+     *
+     * declare module "@apollo/client" {
+     *   export interface TypeOverrides {
+     *     Complete: CompleteOverrideHKT;
+     *   }
+     * }
+     * ```
+     */
+    type Complete<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Complete", OverridableTypes.Defaults, TData>;
+    /**
+     * Returns a representation of `TData` while it is streaming.
+     *
+     * @defaultValue `TData` if no overrides are provided.
+     *
+     * @example
+     * You can override this type globally - this example shows how to override it
+     * with `DeepPartial<TData>`:
+     *
+     * ```ts
+     * import { HKT, DeepPartial } from "@apollo/client/utilities";
+     *
+     * type StreamingOverride<TData> = DeepPartial<TData>;
+     *
+     * interface StreamingOverrideHKT extends HKT {
+     *   return: StreamingOverride<this["arg1"]>;
+     * }
+     *
+     * declare module "@apollo/client" {
+     *   export interface TypeOverrides {
+     *     Streaming: StreamingOverrideHKT;
+     *   }
+     * }
+     * ```
+     */
+    type Streaming<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Streaming", OverridableTypes.Defaults, TData>;
+    /**
+     * Returns a representation of `TData` while it is partial.
+     *
+     * @defaultValue `DeepPartial<TData>` if no overrides are provided.
+     *
+     * @example
+     * You can override this type globally - this example shows how to override it
+     * with `DeepPartial<TData>`:
+     *
+     * ```ts
+     * import { HKT, DeepPartial } from "@apollo/client/utilities";
+     *
+     * type PartialOverride<TData> = DeepPartial<Complete<TData>>;
+     *
+     * interface PartialOverrideHKT extends HKT {
+     *   return: PartialOverride<this["arg1"]>;
+     * }
+     *
+     * declare module "@apollo/client" {
+     *   export interface TypeOverrides {
+     *     Partial: PartialOverrideHKT;
+     *   }
+     * }
+     * ```
+     */
+    type Partial<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Partial", OverridableTypes.Defaults, TData>;
+}
+export interface DefaultContext extends Record<string, any> {
+    /**
+     * Indicates whether `queryDeduplication` was enabled for the request.
+     */
+    queryDeduplication?: boolean;
+    clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
+}
+/**
+ * Represents an `Error` type, but used throughout Apollo Client to represent
+ * errors that may otherwise fail `instanceof` checks if they are cross-realm
+ * Error instances (see the [`Error.isError` proposal](https://github.com/tc39/proposal-is-error) for more details).
+ *
+ * Apollo Client uses several types of errors throughout the client which can be
+ * narrowed using `instanceof`:
+ *
+ * - `CombinedGraphQLErrors` - `errors` returned from a GraphQL result
+ * - `CombinedProtocolErrors` - Transport-level errors from multipart subscriptions.
+ * - `ServerParseError` - A JSON-parse error when parsing the server response.
+ * - `ServerError` - A non-200 server response.
+ *
+ * @example
+ *
+ * ```ts
+ * import { CombinedGraphQLErrors } from "@apollo/client";
+ *
+ * try {
+ *   await client.query({ query });
+ * } catch (error) {
+ *   // Use `instanceof` to check for more specific types of errors.
+ *   if (error instanceof CombinedGraphQLErrors) {
+ *     error.errors.map((graphQLError) => console.log(graphQLError.message));
+ *   } else {
+ *     console.error(errors);
+ *   }
+ * }
+ * ```
+ */
+export interface ErrorLike {
+    message: string;
+    name: string;
+    stack?: string;
+}
+export type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache.DiffResult<any>, lastDiff: Cache.DiffResult<any> | undefined) => boolean | TResult;
+export type RefetchQueryDescriptor = string | DocumentNode;
+export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | ApolloClient.QueryOptions;
+type RefetchQueriesIncludeShorthand = "all" | "active";
+export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+export type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
+export type RefetchQueriesPromiseResults<TResult> = IsAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloClient.QueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+export interface InternalRefetchQueriesOptions<TCache extends ApolloCache, TResult> extends Omit<ApolloClient.RefetchQueriesOptions<TCache, TResult>, "include"> {
+    include?: InternalRefetchQueriesInclude;
+    removeOptimistic?: string;
+}
+export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloClient.QueryResult<any>> : TResult;
+export type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
+export type OperationVariables = Record<string, any>;
+export type DataState<TData> = {
+    /**
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: DataValue.Complete<TData>;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
+    */
+    dataState: "complete";
+} | {
+    /**
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: DataValue.Streaming<TData>;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
+    */
+    dataState: "streaming";
+} | {
+    /**
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: DataValue.Partial<TData>;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
+    */
+    dataState: "partial";
+} | {
+    /**
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: undefined;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
+    */
+    dataState: "empty";
+};
+export type GetDataState<TData, TState extends DataState<TData>["dataState"]> = Extract<DataState<TData>, {
+    dataState: TState;
+}>;
+/**
+ * Represents a result that might be complete or still streaming and
+ * has been normalized into a plain GraphQL result. When the result is
+ * still `streaming`, some fields might not yet be available.
+ */
+export type NormalizedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = Omit<FormattedExecutionResult<TData, TExtensions>, "data"> & GetDataState<TData, "streaming" | "complete">;
+export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: NormalizedExecutionResult<Unmasked<T>>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+export type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+export type MutationUpdaterFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache> = (cache: TCache, result: FormattedExecutionResult<Unmasked<TData>>, options: {
+    context?: DefaultContext;
+    variables?: TVariables;
+}) => void;
+export declare namespace QueryNotification {
+    type NewNetworkStatus = NextNotification<{
+        resetError?: boolean;
+    }> & {
+        source: "newNetworkStatus";
+    };
+    type SetResult<TData> = NextNotification<ObservableQuery.Result<TData>> & {
+        source: "setResult";
+    };
+    type FromNetwork<TData> = ObservableNotification<ObservableQuery.Result<TData>> & {
+        source: "network";
+    };
+    type FromCache<TData> = NextNotification<ObservableQuery.Result<TData>> & {
+        source: "cache";
+    };
+    type Value<TData> = FromCache<TData> | FromNetwork<TData> | NewNetworkStatus | SetResult<TData>;
+}
+/** Observable created by initiating a subscription operation. */
+export interface SubscriptionObservable<T> extends Observable<T> {
+    /**
+     * Used to restart the connection to the link chain. Calling this on a
+     * deduplicated subscription will restart the connection for all observables
+     * that share the request.
+     *
+     * @example
+     *
+     * ```ts
+     * const observable = client.subscribe({ query: subscription });
+     * observable.subscribe((value) => {
+     *   // ...
+     * });
+     *
+     * observable.restart();
+     * ```
+     */
+    restart: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentNode, FormattedExecutionResult } from \"graphql\";\nimport type {\n  NextNotification,\n  Observable,\n  ObservableNotification,\n} from \"rxjs\";\n\nimport type { ApolloCache } from \"@apollo/client/cache\";\nimport type { Cache } from \"@apollo/client/cache\";\nimport type { ClientAwarenessLink } from \"@apollo/client/link/client-awareness\";\nimport type { Unmasked } from \"@apollo/client/masking\";\nimport type { DeepPartial, HKT } from \"@apollo/client/utilities\";\nimport type {\n  ApplyHKTImplementationWithDefault,\n  IsAny,\n} from \"@apollo/client/utilities/internal\";\n\nimport type { ApolloClient } from \"./ApolloClient.js\";\nimport type { ObservableQuery } from \"./ObservableQuery.js\";\n\nexport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\n\nexport interface TypeOverrides {}\n\ndeclare namespace OverridableTypes {\n  export interface Defaults {\n    Complete: Complete;\n    Streaming: Streaming;\n    Partial: Partial;\n  }\n\n  interface Complete extends HKT {\n    arg1: unknown; // TData\n    return: this[\"arg1\"];\n  }\n\n  interface Streaming extends HKT {\n    arg1: unknown; // TData\n    return: this[\"arg1\"];\n  }\n\n  interface Partial extends HKT {\n    arg1: unknown; // TData\n    return: DeepPartial<this[\"arg1\"]>;\n  }\n}\n\nexport declare namespace DataValue {\n  /**\n   * Returns a representation of `TData` in it's \"complete\" state.\n   *\n   * @defaultValue `TData` if no overrides are provided.\n   *\n   * @example\n   * You can override this type globally - this example shows how to override it\n   * with `DeepPartial<TData>`:\n   *\n   * ```ts\n   * import { HKT, DeepPartial } from \"@apollo/client/utilities\";\n   *\n   * type CompleteOverride<TData> =\n   *   TData extends { _complete?: infer _Complete } ? _Complete : TData;\n   *\n   * interface CompleteOverrideHKT extends HKT {\n   *   return: CompleteOverride<this[\"arg1\"]>;\n   * }\n   *\n   * declare module \"@apollo/client\" {\n   *   export interface TypeOverrides {\n   *     Complete: CompleteOverrideHKT;\n   *   }\n   * }\n   * ```\n   */\n  export type Complete<TData> = ApplyHKTImplementationWithDefault<\n    TypeOverrides,\n    \"Complete\",\n    OverridableTypes.Defaults,\n    TData\n  >;\n\n  /**\n   * Returns a representation of `TData` while it is streaming.\n   *\n   * @defaultValue `TData` if no overrides are provided.\n   *\n   * @example\n   * You can override this type globally - this example shows how to override it\n   * with `DeepPartial<TData>`:\n   *\n   * ```ts\n   * import { HKT, DeepPartial } from \"@apollo/client/utilities\";\n   *\n   * type StreamingOverride<TData> = DeepPartial<TData>;\n   *\n   * interface StreamingOverrideHKT extends HKT {\n   *   return: StreamingOverride<this[\"arg1\"]>;\n   * }\n   *\n   * declare module \"@apollo/client\" {\n   *   export interface TypeOverrides {\n   *     Streaming: StreamingOverrideHKT;\n   *   }\n   * }\n   * ```\n   */\n  export type Streaming<TData> = ApplyHKTImplementationWithDefault<\n    TypeOverrides,\n    \"Streaming\",\n    OverridableTypes.Defaults,\n    TData\n  >;\n\n  /**\n   * Returns a representation of `TData` while it is partial.\n   *\n   * @defaultValue `DeepPartial<TData>` if no overrides are provided.\n   *\n   * @example\n   * You can override this type globally - this example shows how to override it\n   * with `DeepPartial<TData>`:\n   *\n   * ```ts\n   * import { HKT, DeepPartial } from \"@apollo/client/utilities\";\n   *\n   * type PartialOverride<TData> = DeepPartial<Complete<TData>>;\n   *\n   * interface PartialOverrideHKT extends HKT {\n   *   return: PartialOverride<this[\"arg1\"]>;\n   * }\n   *\n   * declare module \"@apollo/client\" {\n   *   export interface TypeOverrides {\n   *     Partial: PartialOverrideHKT;\n   *   }\n   * }\n   * ```\n   */\n  export type Partial<TData> = ApplyHKTImplementationWithDefault<\n    TypeOverrides,\n    \"Partial\",\n    OverridableTypes.Defaults,\n    TData\n  >;\n}\n\nexport interface DefaultContext extends Record<string, any> {\n  /**\n   * Indicates whether `queryDeduplication` was enabled for the request.\n   */\n  queryDeduplication?: boolean;\n  clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;\n}\n\n/**\n * Represents an `Error` type, but used throughout Apollo Client to represent\n * errors that may otherwise fail `instanceof` checks if they are cross-realm\n * Error instances (see the [`Error.isError` proposal](https://github.com/tc39/proposal-is-error) for more details).\n *\n * Apollo Client uses several types of errors throughout the client which can be\n * narrowed using `instanceof`:\n *\n * - `CombinedGraphQLErrors` - `errors` returned from a GraphQL result\n * - `CombinedProtocolErrors` - Transport-level errors from multipart subscriptions.\n * - `ServerParseError` - A JSON-parse error when parsing the server response.\n * - `ServerError` - A non-200 server response.\n *\n * @example\n *\n * ```ts\n * import { CombinedGraphQLErrors } from \"@apollo/client\";\n *\n * try {\n *   await client.query({ query });\n * } catch (error) {\n *   // Use `instanceof` to check for more specific types of errors.\n *   if (error instanceof CombinedGraphQLErrors) {\n *     error.errors.map((graphQLError) => console.log(graphQLError.message));\n *   } else {\n *     console.error(errors);\n *   }\n * }\n * ```\n */\nexport interface ErrorLike {\n  message: string;\n  name: string;\n  stack?: string;\n}\n\nexport type OnQueryUpdated<TResult> = (\n  observableQuery: ObservableQuery<any>,\n  diff: Cache.DiffResult<any>,\n  lastDiff: Cache.DiffResult<any> | undefined\n) => boolean | TResult;\n\nexport type RefetchQueryDescriptor = string | DocumentNode;\nexport type InternalRefetchQueryDescriptor =\n  | RefetchQueryDescriptor\n  | ApolloClient.QueryOptions;\n\ntype RefetchQueriesIncludeShorthand = \"all\" | \"active\";\n\nexport type RefetchQueriesInclude =\n  | RefetchQueryDescriptor[]\n  | RefetchQueriesIncludeShorthand;\n\nexport type InternalRefetchQueriesInclude =\n  | InternalRefetchQueryDescriptor[]\n  | RefetchQueriesIncludeShorthand;\n\n// The client.refetchQueries method returns a thenable (PromiseLike) object\n// whose result is an array of Promise.resolve'd TResult values, where TResult\n// is whatever type the (optional) onQueryUpdated function returns. When no\n// onQueryUpdated function is given, TResult defaults to ApolloQueryResult<any>\n// (thanks to default type parameters for client.refetchQueries).\nexport type RefetchQueriesPromiseResults<TResult> =\n  // If onQueryUpdated returns any, all bets are off, so the results array must\n  // be a generic any[] array, which is much less confusing than the union type\n  // we get if we don't check for any. I hoped `any extends TResult` would do\n  // the trick here, instead of IsStrictlyAny, but you can see for yourself what\n  // fails in the refetchQueries tests if you try making that simplification.\n  IsAny<TResult> extends true ? any[]\n  : // If the onQueryUpdated function passed to client.refetchQueries returns true\n  // or false, that means either to refetch the query (true) or to skip the\n  // query (false). Since refetching produces an ApolloQueryResult<any>, and\n  // skipping produces nothing, the fully-resolved array of all results produced\n  // will be an ApolloQueryResult<any>[], when TResult extends boolean.\n  TResult extends boolean ? ApolloClient.QueryResult<any>[]\n  : // If onQueryUpdated returns a PromiseLike<U>, that thenable will be passed as\n  // an array element to Promise.all, so we infer/unwrap the array type U here.\n  TResult extends PromiseLike<infer U> ? U[]\n  : // All other onQueryUpdated results end up in the final Promise.all array as\n    // themselves, with their original TResult type. Note that TResult will\n    // default to ApolloQueryResult<any> if no onQueryUpdated function is passed\n    // to client.refetchQueries.\n    TResult[];\n\n// Used by QueryManager[\"refetchQueries\"]\nexport interface InternalRefetchQueriesOptions<\n  TCache extends ApolloCache,\n  TResult,\n> extends Omit<ApolloClient.RefetchQueriesOptions<TCache, TResult>, \"include\"> {\n  // Just like the refetchQueries option for a mutation, an array of strings,\n  // DocumentNode objects, and/or QueryOptions objects, or one of the shorthand\n  // strings \"all\" or \"active\", to select every (active) query.\n  include?: InternalRefetchQueriesInclude;\n  // This part of the API is a (useful) implementation detail, but need not be\n  // exposed in the public client.refetchQueries API (above).\n  removeOptimistic?: string;\n}\n\nexport type InternalRefetchQueriesResult<TResult> =\n  // If onQueryUpdated returns a boolean, that's equivalent to refetching the\n  // query when the boolean is true and skipping the query when false, so the\n  // internal type of refetched results is Promise<ApolloQueryResult<any>>.\n  TResult extends boolean ? Promise<ApolloClient.QueryResult<any>>\n  : // Otherwise, onQueryUpdated returns whatever it returns. If onQueryUpdated is\n    // not provided, TResult defaults to Promise<ApolloQueryResult<any>> (see the\n    // generic type parameters of client.refetchQueries).\n    TResult;\n\nexport type InternalRefetchQueriesMap<TResult> = Map<\n  ObservableQuery<any>,\n  InternalRefetchQueriesResult<TResult>\n>;\n\nexport type OperationVariables = Record<string, any>;\n\nexport type DataState<TData> =\n  | {\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#data:member} */\n      data: DataValue.Complete<TData>;\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#dataState:member} */\n      dataState: \"complete\";\n    }\n  | {\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#data:member} */\n      data: DataValue.Streaming<TData>;\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#dataState:member} */\n      dataState: \"streaming\";\n    }\n  | {\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#data:member} */\n      data: DataValue.Partial<TData>;\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#dataState:member} */\n      dataState: \"partial\";\n    }\n  | {\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#data:member} */\n      data: undefined;\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#dataState:member} */\n      dataState: \"empty\";\n    };\n\nexport type GetDataState<\n  TData,\n  TState extends DataState<TData>[\"dataState\"],\n> = Extract<DataState<TData>, { dataState: TState }>;\n\n/**\n * Represents a result that might be complete or still streaming and\n * has been normalized into a plain GraphQL result. When the result is\n * still `streaming`, some fields might not yet be available.\n */\nexport type NormalizedExecutionResult<\n  TData = Record<string, unknown>,\n  TExtensions = Record<string, unknown>,\n> = Omit<FormattedExecutionResult<TData, TExtensions>, \"data\"> &\n  GetDataState<TData, \"streaming\" | \"complete\">;\n\n// This is part of the public API, people write these functions in `updateQueries`.\nexport type MutationQueryReducer<T> = (\n  previousResult: Record<string, any>,\n  options: {\n    mutationResult: NormalizedExecutionResult<Unmasked<T>>;\n    queryName: string | undefined;\n    queryVariables: Record<string, any>;\n  }\n) => Record<string, any>;\n\nexport type MutationQueryReducersMap<T = { [key: string]: any }> = {\n  [queryName: string]: MutationQueryReducer<T>;\n};\n\nexport type MutationUpdaterFunction<\n  TData,\n  TVariables extends OperationVariables,\n  TCache extends ApolloCache,\n> = (\n  cache: TCache,\n  result: FormattedExecutionResult<Unmasked<TData>>,\n  options: {\n    context?: DefaultContext;\n    variables?: TVariables;\n  }\n) => void;\n\nexport declare namespace QueryNotification {\n  type NewNetworkStatus = NextNotification<{\n    resetError?: boolean;\n  }> & {\n    source: \"newNetworkStatus\";\n  };\n\n  type SetResult<TData> = NextNotification<ObservableQuery.Result<TData>> & {\n    source: \"setResult\";\n  };\n\n  type FromNetwork<TData> = ObservableNotification<\n    ObservableQuery.Result<TData>\n  > & {\n    source: \"network\";\n  };\n\n  type FromCache<TData> = NextNotification<ObservableQuery.Result<TData>> & {\n    source: \"cache\";\n  };\n\n  type Value<TData> =\n    | FromCache<TData>\n    | FromNetwork<TData>\n    | NewNetworkStatus\n    | SetResult<TData>;\n}\n\n/** Observable created by initiating a subscription operation. */\nexport interface SubscriptionObservable<T> extends Observable<T> {\n  /**\n   * Used to restart the connection to the link chain. Calling this on a\n   * deduplicated subscription will restart the connection for all observables\n   * that share the request.\n   *\n   * @example\n   *\n   * ```ts\n   * const observable = client.subscribe({ query: subscription });\n   * observable.subscribe((value) => {\n   *   // ...\n   * });\n   *\n   * observable.restart();\n   * ```\n   */\n  restart: () => void;\n}\n"]}

package/core/watchQueryOptions.d.ts

@@ -0,0 +1,75 @@
+import type { Unmasked } from "@apollo/client/masking";
+import type { DeepPartial } from "@apollo/client/utilities";
+import type { ApolloClient } from "./ApolloClient.js";
+import type { ObservableQuery } from "./ObservableQuery.js";
+import type { OperationVariables } from "./types.js";
+/**
+ * fetchPolicy determines where the client may return a result from. The options are:
+ *
+ * - cache-first (default): return result from cache. Only fetch from network if cached result is not available.
+ * - cache-and-network: return result from cache first (if it exists), then return network result once it's available.
+ * - cache-only: return result from cache if available, fail otherwise.
+ * - no-cache: return result from network, fail if network call doesn't succeed, don't save to cache
+ * - network-only: return result from network, fail if network call doesn't succeed, save to cache
+ * - standby: only for queries that aren't actively watched, but should be available for refetch and updateQueries.
+ */
+export type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache";
+export type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network" | "standby";
+export type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;
+export type RefetchWritePolicy = "merge" | "overwrite";
+/**
+ * errorPolicy determines the level of events for errors in the execution result. The options are:
+ *
+ * - none (default): any errors from the request are treated like runtime errors and the observable is stopped
+ * - ignore: errors from the request do not stop the observable, but also don't call `next`
+ * - all: errors are treated like data and will notify observables
+ */
+export type ErrorPolicy = "none" | "ignore" | "all";
+export interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
+    reason: "after-fetch" | "variables-changed";
+    observable: ObservableQuery<TData, TVariables>;
+    options: ApolloClient.WatchQueryOptions<TData, TVariables>;
+    initialFetchPolicy: WatchQueryFetchPolicy;
+}
+export type UpdateQueryOptions<TData, TVariables extends OperationVariables> = {
+    variables?: TVariables;
+} & ({
+    /**
+     * Indicate if the previous query result has been found fully in the cache.
+     */
+    complete: true;
+    previousData: Unmasked<TData>;
+} | {
+    /**
+     * Indicate if the previous query result has not been found fully in the cache.
+     * Might have partial or missing data.
+     */
+    complete: false;
+    previousData: DeepPartial<Unmasked<TData>> | undefined;
+});
+export interface UpdateQueryMapFn<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+    (
+    /**
+     * @deprecated This value is not type-safe and may contain partial data. This
+     * argument will be removed in Apollo Client v5. Use `options.previousData`
+     * instead for a more type-safe value.
+     */
+    unsafePreviousData: DeepPartial<Unmasked<TData>>, options: UpdateQueryOptions<TData, TVariables>): Unmasked<TData> | void;
+}
+export type SubscribeToMoreUpdateQueryFn<TData = unknown, TVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData> = {
+    (
+    /**
+     * @deprecated This value is not type-safe and may contain partial data. This
+     * argument will be removed in Apollo Client v5. Use `options.previousData`
+     * instead for a more type-safe value.
+     */
+    unsafePreviousData: DeepPartial<Unmasked<TData>>, options: UpdateQueryOptions<TData, TVariables> & {
+        subscriptionData: {
+            data: Unmasked<TSubscriptionData>;
+        };
+    }): Unmasked<TData> | void;
+};
+export interface SubscribeToMoreFunction<TData, TVariables extends OperationVariables = OperationVariables> {
+    <TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
+}
+//# sourceMappingURL=watchQueryOptions.d.ts.map

package/core/watchQueryOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watchQueryOptions.js.map

package/core/watchQueryOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchQueryOptions.js","sourceRoot":"","sources":["../../src/core/watchQueryOptions.ts"],"names":[],"mappings":"","sourcesContent":["import type { Unmasked } from \"@apollo/client/masking\";\nimport type { DeepPartial } from \"@apollo/client/utilities\";\n\nimport type { ApolloClient } from \"./ApolloClient.js\";\nimport type { ObservableQuery } from \"./ObservableQuery.js\";\nimport type { OperationVariables } from \"./types.js\";\n\n/**\n * fetchPolicy determines where the client may return a result from. The options are:\n *\n * - cache-first (default): return result from cache. Only fetch from network if cached result is not available.\n * - cache-and-network: return result from cache first (if it exists), then return network result once it's available.\n * - cache-only: return result from cache if available, fail otherwise.\n * - no-cache: return result from network, fail if network call doesn't succeed, don't save to cache\n * - network-only: return result from network, fail if network call doesn't succeed, save to cache\n * - standby: only for queries that aren't actively watched, but should be available for refetch and updateQueries.\n */\nexport type FetchPolicy =\n  | \"cache-first\"\n  | \"network-only\"\n  | \"cache-only\"\n  | \"no-cache\";\n\nexport type WatchQueryFetchPolicy =\n  | FetchPolicy\n  | \"cache-and-network\"\n  | \"standby\";\n\nexport type MutationFetchPolicy = Extract<\n  FetchPolicy,\n  | \"network-only\" // default behavior (mutation results written to cache)\n  | \"no-cache\" // alternate behavior (results not written to cache)\n>;\n\nexport type RefetchWritePolicy = \"merge\" | \"overwrite\";\n\n/**\n * errorPolicy determines the level of events for errors in the execution result. The options are:\n *\n * - none (default): any errors from the request are treated like runtime errors and the observable is stopped\n * - ignore: errors from the request do not stop the observable, but also don't call `next`\n * - all: errors are treated like data and will notify observables\n */\nexport type ErrorPolicy = \"none\" | \"ignore\" | \"all\";\n\nexport interface NextFetchPolicyContext<\n  TData,\n  TVariables extends OperationVariables,\n> {\n  reason: \"after-fetch\" | \"variables-changed\";\n  observable: ObservableQuery<TData, TVariables>;\n  options: ApolloClient.WatchQueryOptions<TData, TVariables>;\n  initialFetchPolicy: WatchQueryFetchPolicy;\n}\n\nexport type UpdateQueryOptions<TData, TVariables extends OperationVariables> = {\n  variables?: TVariables;\n} & (\n  | {\n      /**\n       * Indicate if the previous query result has been found fully in the cache.\n       */\n      complete: true;\n      previousData: Unmasked<TData>;\n    }\n  | {\n      /**\n       * Indicate if the previous query result has not been found fully in the cache.\n       * Might have partial or missing data.\n       */\n      complete: false;\n      previousData: DeepPartial<Unmasked<TData>> | undefined;\n    }\n);\n\nexport interface UpdateQueryMapFn<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n> {\n  (\n    /**\n     * @deprecated This value is not type-safe and may contain partial data. This\n     * argument will be removed in Apollo Client v5. Use `options.previousData`\n     * instead for a more type-safe value.\n     */\n    unsafePreviousData: DeepPartial<Unmasked<TData>>,\n    options: UpdateQueryOptions<TData, TVariables>\n  ): Unmasked<TData> | void;\n}\n\nexport type SubscribeToMoreUpdateQueryFn<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n  TSubscriptionData = TData,\n> = {\n  (\n    /**\n     * @deprecated This value is not type-safe and may contain partial data. This\n     * argument will be removed in Apollo Client v5. Use `options.previousData`\n     * instead for a more type-safe value.\n     */\n    unsafePreviousData: DeepPartial<Unmasked<TData>>,\n    options: UpdateQueryOptions<TData, TVariables> & {\n      subscriptionData: { data: Unmasked<TSubscriptionData> };\n    }\n  ): Unmasked<TData> | void;\n};\n\nexport interface SubscribeToMoreFunction<\n  TData,\n  TVariables extends OperationVariables = OperationVariables,\n> {\n  <\n    TSubscriptionData = TData,\n    TSubscriptionVariables extends OperationVariables = TVariables,\n  >(\n    options: ObservableQuery.SubscribeToMoreOptions<\n      TData,\n      TSubscriptionVariables,\n      TSubscriptionData,\n      TVariables\n    >\n  ): () => void;\n}\n"]}