@apollo/client

  • Version 3.7.10
  • Published
  • 4.52 MB
  • 13 dependencies
  • MIT license

Install

npm i @apollo/client
yarn add @apollo/client
pnpm add @apollo/client

Overview

A fully-featured caching GraphQL client.

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ApolloConsumer

const ApolloConsumer: React.FC<ApolloConsumerProps>;

    variable ApolloProvider

    const ApolloProvider: React.FC<ApolloProviderProps<any>>;

      variable concat

      const concat: (
      first: ApolloLink | RequestHandler,
      second: ApolloLink | RequestHandler
      ) => ApolloLink;

        variable defaultPrinter

        const defaultPrinter: Printer;

          variable empty

          const empty: () => ApolloLink;

            variable execute

            const execute: (
            link: ApolloLink,
            operation: GraphQLRequest<Record<string, any>>
            ) => Observable<
            FetchResult<Record<string, any>, Record<string, any>, Record<string, any>>
            >;

              variable fallbackHttpConfig

              const fallbackHttpConfig: {
              http: HttpQueryOptions;
              headers: { accept: string; 'content-type': string };
              options: { method: string };
              };

                variable from

                const from: (links: (ApolloLink | RequestHandler)[]) => ApolloLink;

                  variable split

                  const split: (
                  test: (op: Operation) => boolean,
                  left: ApolloLink | RequestHandler,
                  right?: ApolloLink | RequestHandler
                  ) => ApolloLink;

                    Functions

                    function checkFetcher

                    checkFetcher: (fetcher: WindowOrWorkerGlobalScope['fetch'] | undefined) => void;
                      createHttpLink: (linkOptions?: HttpOptions) => ApolloLink;

                        function createSignalIfSupported

                        createSignalIfSupported: () =>
                        | { controller: boolean; signal: boolean }
                        | { controller: AbortController; signal: AbortSignal };

                          function defaultDataIdFromObject

                          defaultDataIdFromObject: (
                          { __typename, id, _id }: Readonly<StoreObject>,
                          context?: KeyFieldsContext
                          ) => string | undefined;

                            function fromError

                            fromError: <T>(errorValue: any) => Observable<T>;

                              function fromPromise

                              fromPromise: <T>(promise: Promise<T>) => Observable<T>;

                                function getApolloContext

                                getApolloContext: () => React.Context<ApolloContextValue>;

                                  function isApolloError

                                  isApolloError: (err: Error) => err is ApolloError;

                                    function isReference

                                    isReference: (obj: any) => obj is Reference;

                                      function makeReference

                                      makeReference: (id: string) => Reference;

                                        function makeVar

                                        makeVar: <T>(value: T) => ReactiveVar<T>;

                                          function mergeOptions

                                          mergeOptions: <TOptions extends Partial<OptionsUnion<any, any, any>>>(
                                          defaults: TOptions | Partial<TOptions> | undefined,
                                          options: TOptions | Partial<TOptions>
                                          ) => TOptions;

                                            function operationName

                                            operationName: (type: DocumentType) => string;

                                              function parseAndCheckHttpResponse

                                              parseAndCheckHttpResponse: (
                                              operations: Operation | Operation[]
                                              ) => (response: Response) => Promise<any>;

                                                function parser

                                                parser: (document: DocumentNode) => IDocumentDefinition;

                                                  function resetApolloContext

                                                  resetApolloContext: () => React.Context<ApolloContextValue>;

                                                    function rewriteURIForGET

                                                    rewriteURIForGET: (
                                                    chosenURI: string,
                                                    body: Body
                                                    ) =>
                                                    | { parseError: any; newURI?: undefined }
                                                    | { newURI: string; parseError?: undefined };

                                                      function selectHttpOptionsAndBody

                                                      selectHttpOptionsAndBody: (
                                                      operation: Operation,
                                                      fallbackConfig: HttpConfig,
                                                      ...configs: Array<HttpConfig>
                                                      ) => { options: HttpConfig & Record<string, any>; body: Body };

                                                        function selectHttpOptionsAndBodyInternal

                                                        selectHttpOptionsAndBodyInternal: (
                                                        operation: Operation,
                                                        printer: Printer,
                                                        ...configs: HttpConfig[]
                                                        ) => { options: HttpConfig & Record<string, any>; body: Body };

                                                          function selectURI

                                                          selectURI: (
                                                          operation: Operation,
                                                          fallbackURI?: string | ((operation: Operation) => string)
                                                          ) => any;

                                                            function serializeFetchParameter

                                                            serializeFetchParameter: (p: any, label: string) => string;

                                                              function throwServerError

                                                              throwServerError: (response: Response, result: any, message: string) => never;

                                                                function toPromise

                                                                toPromise: <R>(observable: Observable<R>) => Promise<R>;

                                                                  function useApolloClient

                                                                  useApolloClient: (override?: ApolloClient<object>) => ApolloClient<object>;

                                                                    function useFragment_experimental

                                                                    useFragment_experimental: <TData = any, TVars = OperationVariables>(
                                                                    options: UseFragmentOptions<TData, TVars>
                                                                    ) => UseFragmentResult<TData>;

                                                                      function useLazyQuery

                                                                      useLazyQuery: <
                                                                      TData = any,
                                                                      TVariables extends OperationVariables = OperationVariables
                                                                      >(
                                                                      query: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                      options?: LazyQueryHookOptions<TData, TVariables>
                                                                      ) => LazyQueryResultTuple<TData, TVariables>;

                                                                        function useMutation

                                                                        useMutation: <
                                                                        TData = any,
                                                                        TVariables = OperationVariables,
                                                                        TContext = DefaultContext,
                                                                        TCache extends ApolloCache<any> = ApolloCache<any>
                                                                        >(
                                                                        mutation: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                        options?: MutationHookOptions<TData, TVariables, TContext, TCache>
                                                                        ) => MutationTuple<TData, TVariables, TContext, TCache>;

                                                                          function useQuery

                                                                          useQuery: <
                                                                          TData = any,
                                                                          TVariables extends OperationVariables = OperationVariables
                                                                          >(
                                                                          query: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                          options?: QueryHookOptions<TData, TVariables>
                                                                          ) => QueryResult<TData, TVariables>;

                                                                            function useReactiveVar

                                                                            useReactiveVar: <T>(rv: ReactiveVar<T>) => T;

                                                                              function useSubscription

                                                                              useSubscription: <
                                                                              TData = any,
                                                                              TVariables extends OperationVariables = OperationVariables
                                                                              >(
                                                                              subscription: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                              options?: SubscriptionHookOptions<TData, TVariables>
                                                                              ) => SubscriptionResult<TData, any>;

                                                                                Classes

                                                                                class ApolloCache

                                                                                abstract class ApolloCache<TSerialized> implements DataProxy {}

                                                                                  method batch

                                                                                  batch: <U>(options: Cache.BatchOptions<this, U>) => U;

                                                                                    method diff

                                                                                    abstract diff: <T>(query: Cache.DiffOptions) => Cache.DiffResult<T>;

                                                                                      method evict

                                                                                      abstract evict: (options: Cache.EvictOptions) => boolean;

                                                                                        method extract

                                                                                        abstract extract: (optimistic?: boolean) => TSerialized;

                                                                                          method gc

                                                                                          gc: () => string[];

                                                                                            method identify

                                                                                            identify: (object: StoreObject | Reference) => string | undefined;

                                                                                              method modify

                                                                                              modify: (options: Cache.ModifyOptions) => boolean;

                                                                                                method performTransaction

                                                                                                abstract performTransaction: (
                                                                                                transaction: Transaction<TSerialized>,
                                                                                                optimisticId?: string | null
                                                                                                ) => void;

                                                                                                  method read

                                                                                                  abstract read: <TData = any, TVariables = any>(
                                                                                                  query: Cache.ReadOptions<TVariables, TData>
                                                                                                  ) => TData | null;

                                                                                                    method readFragment

                                                                                                    readFragment: <FragmentType, TVariables = any>(
                                                                                                    options: Cache.ReadFragmentOptions<FragmentType, TVariables>,
                                                                                                    optimistic?: boolean
                                                                                                    ) => FragmentType | null;

                                                                                                      method readQuery

                                                                                                      readQuery: <QueryType, TVariables = any>(
                                                                                                      options: Cache.ReadQueryOptions<QueryType, TVariables>,
                                                                                                      optimistic?: boolean
                                                                                                      ) => QueryType | null;

                                                                                                        method recordOptimisticTransaction

                                                                                                        recordOptimisticTransaction: (
                                                                                                        transaction: Transaction<TSerialized>,
                                                                                                        optimisticId: string
                                                                                                        ) => void;

                                                                                                          method removeOptimistic

                                                                                                          abstract removeOptimistic: (id: string) => void;

                                                                                                            method reset

                                                                                                            abstract reset: (options?: Cache.ResetOptions) => Promise<void>;

                                                                                                              method restore

                                                                                                              abstract restore: (serializedState: TSerialized) => ApolloCache<TSerialized>;

                                                                                                                method transformDocument

                                                                                                                transformDocument: (document: DocumentNode) => DocumentNode;
                                                                                                                  transformForLink: (document: DocumentNode) => DocumentNode;

                                                                                                                    method updateFragment

                                                                                                                    updateFragment: <TData = any, TVariables = any>(
                                                                                                                    options: Cache.UpdateFragmentOptions<TData, TVariables>,
                                                                                                                    update: (data: TData | null) => TData | null | void
                                                                                                                    ) => TData | null;

                                                                                                                      method updateQuery

                                                                                                                      updateQuery: <TData = any, TVariables = any>(
                                                                                                                      options: Cache.UpdateQueryOptions<TData, TVariables>,
                                                                                                                      update: (data: TData | null) => TData | null | void
                                                                                                                      ) => TData | null;

                                                                                                                        method watch

                                                                                                                        abstract watch: <TData = any, TVariables = any>(
                                                                                                                        watch: Cache.WatchOptions<TData, TVariables>
                                                                                                                        ) => () => void;

                                                                                                                          method write

                                                                                                                          abstract write: <TData = any, TVariables = any>(
                                                                                                                          write: Cache.WriteOptions<TData, TVariables>
                                                                                                                          ) => Reference | undefined;

                                                                                                                            method writeFragment

                                                                                                                            writeFragment: <TData = any, TVariables = any>({
                                                                                                                            id,
                                                                                                                            data,
                                                                                                                            fragment,
                                                                                                                            fragmentName,
                                                                                                                            ...options
                                                                                                                            }: Cache.WriteFragmentOptions<TData, TVariables>) => Reference | undefined;

                                                                                                                              method writeQuery

                                                                                                                              writeQuery: <TData = any, TVariables = any>({
                                                                                                                              id,
                                                                                                                              data,
                                                                                                                              ...options
                                                                                                                              }: Cache.WriteQueryOptions<TData, TVariables>) => Reference | undefined;

                                                                                                                                class ApolloClient

                                                                                                                                class ApolloClient<TCacheShape> implements DataProxy {}

                                                                                                                                  constructor

                                                                                                                                  constructor(options: ApolloClientOptions<TCacheShape>);

                                                                                                                                    property cache

                                                                                                                                    cache: ApolloCache<TCacheShape>;

                                                                                                                                      property defaultOptions

                                                                                                                                      defaultOptions: DefaultOptions;

                                                                                                                                        property disableNetworkFetches

                                                                                                                                        disableNetworkFetches: boolean;
                                                                                                                                          link: ApolloLink;

                                                                                                                                            property queryDeduplication

                                                                                                                                            queryDeduplication: boolean;

                                                                                                                                              property typeDefs

                                                                                                                                              readonly typeDefs: any;

                                                                                                                                                property version

                                                                                                                                                version: string;

                                                                                                                                                  method addResolvers

                                                                                                                                                  addResolvers: (resolvers: Resolvers | Resolvers[]) => void;

                                                                                                                                                    method clearStore

                                                                                                                                                    clearStore: () => Promise<any[]>;

                                                                                                                                                      method extract

                                                                                                                                                      extract: (optimistic?: boolean) => TCacheShape;

                                                                                                                                                        method getObservableQueries

                                                                                                                                                        getObservableQueries: (
                                                                                                                                                        include?: RefetchQueriesInclude
                                                                                                                                                        ) => Map<string, ObservableQuery<any>>;

                                                                                                                                                          method getResolvers

                                                                                                                                                          getResolvers: () => Resolvers;

                                                                                                                                                            method mutate

                                                                                                                                                            mutate: <
                                                                                                                                                            TData = any,
                                                                                                                                                            TVariables extends OperationVariables = OperationVariables,
                                                                                                                                                            TContext extends Record<string, any> = DefaultContext,
                                                                                                                                                            TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                            >(
                                                                                                                                                            options: MutationOptions<TData, TVariables, TContext>
                                                                                                                                                            ) => Promise<FetchResult<TData>>;

                                                                                                                                                              method onClearStore

                                                                                                                                                              onClearStore: (cb: () => Promise<any>) => () => void;

                                                                                                                                                                method onResetStore

                                                                                                                                                                onResetStore: (cb: () => Promise<any>) => () => void;

                                                                                                                                                                  method query

                                                                                                                                                                  query: <T = any, TVariables extends OperationVariables = OperationVariables>(
                                                                                                                                                                  options: QueryOptions<TVariables, T>
                                                                                                                                                                  ) => Promise<ApolloQueryResult<T>>;

                                                                                                                                                                    method readFragment

                                                                                                                                                                    readFragment: <T = any, TVariables = OperationVariables>(
                                                                                                                                                                    options: DataProxy.Fragment<TVariables, T>,
                                                                                                                                                                    optimistic?: boolean
                                                                                                                                                                    ) => T | null;

                                                                                                                                                                      method readQuery

                                                                                                                                                                      readQuery: <T = any, TVariables = OperationVariables>(
                                                                                                                                                                      options: DataProxy.Query<TVariables, T>,
                                                                                                                                                                      optimistic?: boolean
                                                                                                                                                                      ) => T | null;

                                                                                                                                                                        method reFetchObservableQueries

                                                                                                                                                                        reFetchObservableQueries: (
                                                                                                                                                                        includeStandby?: boolean
                                                                                                                                                                        ) => Promise<ApolloQueryResult<any>[]>;

                                                                                                                                                                          method refetchQueries

                                                                                                                                                                          refetchQueries: <
                                                                                                                                                                          TCache extends ApolloCache<any> = ApolloCache<TCacheShape>,
                                                                                                                                                                          TResult = Promise<ApolloQueryResult<any>>
                                                                                                                                                                          >(
                                                                                                                                                                          options: RefetchQueriesOptions<TCache, TResult>
                                                                                                                                                                          ) => RefetchQueriesResult<TResult>;

                                                                                                                                                                            method resetStore

                                                                                                                                                                            resetStore: () => Promise<ApolloQueryResult<any>[] | null>;

                                                                                                                                                                              method restore

                                                                                                                                                                              restore: (serializedState: TCacheShape) => ApolloCache<TCacheShape>;
                                                                                                                                                                                setLink: (newLink: ApolloLink) => void;

                                                                                                                                                                                  method setLocalStateFragmentMatcher

                                                                                                                                                                                  setLocalStateFragmentMatcher: (fragmentMatcher: FragmentMatcher) => void;

                                                                                                                                                                                    method setResolvers

                                                                                                                                                                                    setResolvers: (resolvers: Resolvers | Resolvers[]) => void;

                                                                                                                                                                                      method stop

                                                                                                                                                                                      stop: () => void;

                                                                                                                                                                                        method subscribe

                                                                                                                                                                                        subscribe: <T = any, TVariables extends OperationVariables = OperationVariables>(
                                                                                                                                                                                        options: SubscriptionOptions<TVariables, T>
                                                                                                                                                                                        ) => Observable<FetchResult<T, Record<string, any>, Record<string, any>>>;

                                                                                                                                                                                          method watchQuery

                                                                                                                                                                                          watchQuery: <
                                                                                                                                                                                          T = any,
                                                                                                                                                                                          TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                          >(
                                                                                                                                                                                          options: WatchQueryOptions<TVariables, T>
                                                                                                                                                                                          ) => ObservableQuery<T, TVariables>;

                                                                                                                                                                                            method writeFragment

                                                                                                                                                                                            writeFragment: <TData = any, TVariables = OperationVariables>(
                                                                                                                                                                                            options: DataProxy.WriteFragmentOptions<TData, TVariables>
                                                                                                                                                                                            ) => Reference | undefined;

                                                                                                                                                                                              method writeQuery

                                                                                                                                                                                              writeQuery: <TData = any, TVariables = OperationVariables>(
                                                                                                                                                                                              options: DataProxy.WriteQueryOptions<TData, TVariables>
                                                                                                                                                                                              ) => Reference | undefined;

                                                                                                                                                                                                class ApolloError

                                                                                                                                                                                                class ApolloError extends Error {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor({
                                                                                                                                                                                                  graphQLErrors,
                                                                                                                                                                                                  clientErrors,
                                                                                                                                                                                                  networkError,
                                                                                                                                                                                                  errorMessage,
                                                                                                                                                                                                  extraInfo,
                                                                                                                                                                                                  }: {
                                                                                                                                                                                                  graphQLErrors?: ReadonlyArray<GraphQLError>;
                                                                                                                                                                                                  clientErrors?: ReadonlyArray<Error>;
                                                                                                                                                                                                  networkError?: Error | ServerParseError | ServerError | null;
                                                                                                                                                                                                  errorMessage?: string;
                                                                                                                                                                                                  extraInfo?: any;
                                                                                                                                                                                                  });

                                                                                                                                                                                                    property clientErrors

                                                                                                                                                                                                    clientErrors: readonly Error[];

                                                                                                                                                                                                      property extraInfo

                                                                                                                                                                                                      extraInfo: any;

                                                                                                                                                                                                        property graphQLErrors

                                                                                                                                                                                                        graphQLErrors: GraphQLErrors;

                                                                                                                                                                                                          property message

                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                            property name

                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                              property networkError

                                                                                                                                                                                                              networkError: Error | ServerParseError | ServerError;
                                                                                                                                                                                                                class ApolloLink {}

                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                  constructor(request?: RequestHandler);

                                                                                                                                                                                                                    method concat

                                                                                                                                                                                                                    static concat: (
                                                                                                                                                                                                                    first: ApolloLink | RequestHandler,
                                                                                                                                                                                                                    second: ApolloLink | RequestHandler
                                                                                                                                                                                                                    ) => ApolloLink;

                                                                                                                                                                                                                      method empty

                                                                                                                                                                                                                      static empty: () => ApolloLink;

                                                                                                                                                                                                                        method execute

                                                                                                                                                                                                                        static execute: (
                                                                                                                                                                                                                        link: ApolloLink,
                                                                                                                                                                                                                        operation: GraphQLRequest
                                                                                                                                                                                                                        ) => Observable<
                                                                                                                                                                                                                        FetchResult<Record<string, any>, Record<string, any>, Record<string, any>>
                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                          method from

                                                                                                                                                                                                                          static from: (links: (ApolloLink | RequestHandler)[]) => ApolloLink;

                                                                                                                                                                                                                            method onError

                                                                                                                                                                                                                            protected onError: (
                                                                                                                                                                                                                            error: any,
                                                                                                                                                                                                                            observer?: Observer<
                                                                                                                                                                                                                            FetchResult<
                                                                                                                                                                                                                            Record<string, any>,
                                                                                                                                                                                                                            Record<string, any>,
                                                                                                                                                                                                                            Record<string, any>
                                                                                                                                                                                                                            >
                                                                                                                                                                                                                            >
                                                                                                                                                                                                                            ) => false | void;

                                                                                                                                                                                                                              method request

                                                                                                                                                                                                                              request: (
                                                                                                                                                                                                                              operation: Operation,
                                                                                                                                                                                                                              forward?: NextLink
                                                                                                                                                                                                                              ) => Observable<FetchResult> | null;

                                                                                                                                                                                                                                method setOnError

                                                                                                                                                                                                                                setOnError: (fn: ApolloLink['onError']) => this;

                                                                                                                                                                                                                                  method split

                                                                                                                                                                                                                                  static split: (
                                                                                                                                                                                                                                  test: (op: Operation) => boolean,
                                                                                                                                                                                                                                  left: ApolloLink | RequestHandler,
                                                                                                                                                                                                                                  right?: ApolloLink | RequestHandler
                                                                                                                                                                                                                                  ) => ApolloLink;
                                                                                                                                                                                                                                    class HttpLink extends ApolloLink {}

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(options?: HttpOptions);

                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                        options: HttpOptions;

                                                                                                                                                                                                                                          property requester

                                                                                                                                                                                                                                          requester: RequestHandler;

                                                                                                                                                                                                                                            class InMemoryCache

                                                                                                                                                                                                                                            class InMemoryCache extends ApolloCache<NormalizedCacheObject> {}

                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                              constructor(config?: InMemoryCacheConfig);

                                                                                                                                                                                                                                                property config

                                                                                                                                                                                                                                                protected config: InMemoryCacheConfig;

                                                                                                                                                                                                                                                  property makeVar

                                                                                                                                                                                                                                                  readonly makeVar: <T>(value: T) => ReactiveVar<T>;

                                                                                                                                                                                                                                                    property policies

                                                                                                                                                                                                                                                    readonly policies: Policies;

                                                                                                                                                                                                                                                      method batch

                                                                                                                                                                                                                                                      batch: <TUpdateResult>(
                                                                                                                                                                                                                                                      options: Cache.BatchOptions<InMemoryCache, TUpdateResult>
                                                                                                                                                                                                                                                      ) => TUpdateResult;

                                                                                                                                                                                                                                                        method broadcastWatches

                                                                                                                                                                                                                                                        protected broadcastWatches: (options?: BroadcastOptions) => void;

                                                                                                                                                                                                                                                          method diff

                                                                                                                                                                                                                                                          diff: <TData, TVariables extends OperationVariables = any>(
                                                                                                                                                                                                                                                          options: Cache.DiffOptions<TData, TVariables>
                                                                                                                                                                                                                                                          ) => Cache.DiffResult<TData>;

                                                                                                                                                                                                                                                            method evict

                                                                                                                                                                                                                                                            evict: (options: Cache.EvictOptions) => boolean;

                                                                                                                                                                                                                                                              method extract

                                                                                                                                                                                                                                                              extract: (optimistic?: boolean) => NormalizedCacheObject;

                                                                                                                                                                                                                                                                method gc

                                                                                                                                                                                                                                                                gc: (options?: {
                                                                                                                                                                                                                                                                resetResultCache?: boolean;
                                                                                                                                                                                                                                                                resetResultIdentities?: boolean;
                                                                                                                                                                                                                                                                }) => string[];

                                                                                                                                                                                                                                                                  method identify

                                                                                                                                                                                                                                                                  identify: (object: StoreObject | Reference) => string | undefined;

                                                                                                                                                                                                                                                                    method modify

                                                                                                                                                                                                                                                                    modify: (options: Cache.ModifyOptions) => boolean;

                                                                                                                                                                                                                                                                      method performTransaction

                                                                                                                                                                                                                                                                      performTransaction: (
                                                                                                                                                                                                                                                                      update: (cache: InMemoryCache) => any,
                                                                                                                                                                                                                                                                      optimisticId?: string | null
                                                                                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                                                                                        method read

                                                                                                                                                                                                                                                                        read: <T>(options: Cache.ReadOptions) => T | null;

                                                                                                                                                                                                                                                                          method release

                                                                                                                                                                                                                                                                          release: (rootId: string, optimistic?: boolean) => number;

                                                                                                                                                                                                                                                                            method removeOptimistic

                                                                                                                                                                                                                                                                            removeOptimistic: (idToRemove: string) => void;

                                                                                                                                                                                                                                                                              method reset

                                                                                                                                                                                                                                                                              reset: (options?: Cache.ResetOptions) => Promise<void>;

                                                                                                                                                                                                                                                                                method restore

                                                                                                                                                                                                                                                                                restore: (data: NormalizedCacheObject) => this;

                                                                                                                                                                                                                                                                                  method retain

                                                                                                                                                                                                                                                                                  retain: (rootId: string, optimistic?: boolean) => number;

                                                                                                                                                                                                                                                                                    method transformDocument

                                                                                                                                                                                                                                                                                    transformDocument: (document: DocumentNode) => DocumentNode;
                                                                                                                                                                                                                                                                                      transformForLink: (document: DocumentNode) => DocumentNode;

                                                                                                                                                                                                                                                                                        method watch

                                                                                                                                                                                                                                                                                        watch: <TData = any, TVariables = any>(
                                                                                                                                                                                                                                                                                        watch: Cache.WatchOptions<TData, TVariables>
                                                                                                                                                                                                                                                                                        ) => () => void;

                                                                                                                                                                                                                                                                                          method write

                                                                                                                                                                                                                                                                                          write: (options: Cache.WriteOptions) => Reference | undefined;

                                                                                                                                                                                                                                                                                            class MissingFieldError

                                                                                                                                                                                                                                                                                            class MissingFieldError extends Error {}

                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                              message: string,
                                                                                                                                                                                                                                                                                              path: MissingTree | (string | number)[],
                                                                                                                                                                                                                                                                                              query: DocumentNode,
                                                                                                                                                                                                                                                                                              variables?: Record<string, any>
                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                                                                                readonly message: string;

                                                                                                                                                                                                                                                                                                  property missing

                                                                                                                                                                                                                                                                                                  readonly missing: MissingTree;

                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                    readonly path: MissingTree | (string | number)[];

                                                                                                                                                                                                                                                                                                      property query

                                                                                                                                                                                                                                                                                                      readonly query: DocumentNode;

                                                                                                                                                                                                                                                                                                        property variables

                                                                                                                                                                                                                                                                                                        readonly variables?: Record<string, any>;

                                                                                                                                                                                                                                                                                                          class ObservableQuery

                                                                                                                                                                                                                                                                                                          class ObservableQuery<
                                                                                                                                                                                                                                                                                                          TData = any,
                                                                                                                                                                                                                                                                                                          TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                          > extends Observable<ApolloQueryResult<TData>> {}

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor({
                                                                                                                                                                                                                                                                                                            queryManager,
                                                                                                                                                                                                                                                                                                            queryInfo,
                                                                                                                                                                                                                                                                                                            options,
                                                                                                                                                                                                                                                                                                            }: {
                                                                                                                                                                                                                                                                                                            queryManager: QueryManager<any>;
                                                                                                                                                                                                                                                                                                            queryInfo: QueryInfo;
                                                                                                                                                                                                                                                                                                            options: WatchQueryOptions<TVariables, TData>;
                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                                                                              readonly options: WatchQueryOptions<TVariables, TData>;

                                                                                                                                                                                                                                                                                                                property query

                                                                                                                                                                                                                                                                                                                readonly query: TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                  property queryId

                                                                                                                                                                                                                                                                                                                  readonly queryId: string;

                                                                                                                                                                                                                                                                                                                    property queryName

                                                                                                                                                                                                                                                                                                                    readonly queryName?: string;

                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                      readonly variables: OperationVariables;

                                                                                                                                                                                                                                                                                                                        method fetchMore

                                                                                                                                                                                                                                                                                                                        fetchMore: <
                                                                                                                                                                                                                                                                                                                        TFetchData = TData,
                                                                                                                                                                                                                                                                                                                        TFetchVars extends OperationVariables = TVariables
                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                        fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
                                                                                                                                                                                                                                                                                                                        updateQuery?: (
                                                                                                                                                                                                                                                                                                                        previousQueryResult: TData,
                                                                                                                                                                                                                                                                                                                        options: { fetchMoreResult: TFetchData; variables: TFetchVars }
                                                                                                                                                                                                                                                                                                                        ) => TData;
                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                        ) => Promise<ApolloQueryResult<TFetchData>>;

                                                                                                                                                                                                                                                                                                                          method getCurrentResult

                                                                                                                                                                                                                                                                                                                          getCurrentResult: (saveAsLastResult?: boolean) => ApolloQueryResult<TData>;

                                                                                                                                                                                                                                                                                                                            method getLastError

                                                                                                                                                                                                                                                                                                                            getLastError: (variablesMustMatch?: boolean) => ApolloError | undefined;

                                                                                                                                                                                                                                                                                                                              method getLastResult

                                                                                                                                                                                                                                                                                                                              getLastResult: (
                                                                                                                                                                                                                                                                                                                              variablesMustMatch?: boolean
                                                                                                                                                                                                                                                                                                                              ) => ApolloQueryResult<TData> | undefined;

                                                                                                                                                                                                                                                                                                                                method hasObservers

                                                                                                                                                                                                                                                                                                                                hasObservers: () => boolean;

                                                                                                                                                                                                                                                                                                                                  method isDifferentFromLastResult

                                                                                                                                                                                                                                                                                                                                  isDifferentFromLastResult: (
                                                                                                                                                                                                                                                                                                                                  newResult: ApolloQueryResult<TData>,
                                                                                                                                                                                                                                                                                                                                  variables?: TVariables
                                                                                                                                                                                                                                                                                                                                  ) => boolean | undefined;

                                                                                                                                                                                                                                                                                                                                    method refetch

                                                                                                                                                                                                                                                                                                                                    refetch: (variables?: Partial<TVariables>) => Promise<ApolloQueryResult<TData>>;

                                                                                                                                                                                                                                                                                                                                      method reobserve

                                                                                                                                                                                                                                                                                                                                      reobserve: (
                                                                                                                                                                                                                                                                                                                                      newOptions?: Partial<WatchQueryOptions<TVariables, TData>>,
                                                                                                                                                                                                                                                                                                                                      newNetworkStatus?: NetworkStatus
                                                                                                                                                                                                                                                                                                                                      ) => Promise<ApolloQueryResult<TData>>;

                                                                                                                                                                                                                                                                                                                                        method resetLastResults

                                                                                                                                                                                                                                                                                                                                        resetLastResults: () => void;

                                                                                                                                                                                                                                                                                                                                          method resetQueryStoreErrors

                                                                                                                                                                                                                                                                                                                                          resetQueryStoreErrors: () => void;

                                                                                                                                                                                                                                                                                                                                            method result

                                                                                                                                                                                                                                                                                                                                            result: () => Promise<ApolloQueryResult<TData>>;

                                                                                                                                                                                                                                                                                                                                              method setOptions

                                                                                                                                                                                                                                                                                                                                              setOptions: (
                                                                                                                                                                                                                                                                                                                                              newOptions: Partial<WatchQueryOptions<TVariables, TData>>
                                                                                                                                                                                                                                                                                                                                              ) => Promise<ApolloQueryResult<TData>>;

                                                                                                                                                                                                                                                                                                                                                method setVariables

                                                                                                                                                                                                                                                                                                                                                setVariables: (
                                                                                                                                                                                                                                                                                                                                                variables: TVariables
                                                                                                                                                                                                                                                                                                                                                ) => Promise<ApolloQueryResult<TData> | void>;

                                                                                                                                                                                                                                                                                                                                                  method startPolling

                                                                                                                                                                                                                                                                                                                                                  startPolling: (pollInterval: number) => void;

                                                                                                                                                                                                                                                                                                                                                    method stopPolling

                                                                                                                                                                                                                                                                                                                                                    stopPolling: () => void;

                                                                                                                                                                                                                                                                                                                                                      method subscribeToMore

                                                                                                                                                                                                                                                                                                                                                      subscribeToMore: <
                                                                                                                                                                                                                                                                                                                                                      TSubscriptionData = TData,
                                                                                                                                                                                                                                                                                                                                                      TSubscriptionVariables extends OperationVariables = TVariables
                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                      options: SubscribeToMoreOptions<
                                                                                                                                                                                                                                                                                                                                                      TData,
                                                                                                                                                                                                                                                                                                                                                      TSubscriptionVariables,
                                                                                                                                                                                                                                                                                                                                                      TSubscriptionData
                                                                                                                                                                                                                                                                                                                                                      >
                                                                                                                                                                                                                                                                                                                                                      ) => () => void;

                                                                                                                                                                                                                                                                                                                                                        method updateQuery

                                                                                                                                                                                                                                                                                                                                                        updateQuery: <TVars extends OperationVariables = TVariables>(
                                                                                                                                                                                                                                                                                                                                                        mapFn: (
                                                                                                                                                                                                                                                                                                                                                        previousQueryResult: TData,
                                                                                                                                                                                                                                                                                                                                                        options: Pick<WatchQueryOptions<TVars, TData>, 'variables'>
                                                                                                                                                                                                                                                                                                                                                        ) => TData
                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                          Interfaces

                                                                                                                                                                                                                                                                                                                                                          interface ApolloContextValue

                                                                                                                                                                                                                                                                                                                                                          interface ApolloContextValue {}

                                                                                                                                                                                                                                                                                                                                                            property client

                                                                                                                                                                                                                                                                                                                                                            client?: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                              property renderPromises

                                                                                                                                                                                                                                                                                                                                                              renderPromises?: RenderPromises;

                                                                                                                                                                                                                                                                                                                                                                interface BaseMutationOptions

                                                                                                                                                                                                                                                                                                                                                                interface BaseMutationOptions<
                                                                                                                                                                                                                                                                                                                                                                TData = any,
                                                                                                                                                                                                                                                                                                                                                                TVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                > extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, 'mutation'> {}

                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                  client?: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                    property ignoreResults

                                                                                                                                                                                                                                                                                                                                                                    ignoreResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                      property notifyOnNetworkStatusChange

                                                                                                                                                                                                                                                                                                                                                                      notifyOnNetworkStatusChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                        property onCompleted

                                                                                                                                                                                                                                                                                                                                                                        onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                          property onError

                                                                                                                                                                                                                                                                                                                                                                          onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                            interface BaseQueryOptions

                                                                                                                                                                                                                                                                                                                                                                            interface BaseQueryOptions<
                                                                                                                                                                                                                                                                                                                                                                            TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                            > extends Omit<WatchQueryOptions<TVariables>, 'query'> {}

                                                                                                                                                                                                                                                                                                                                                                              property client

                                                                                                                                                                                                                                                                                                                                                                              client?: ApolloClient<any>;

                                                                                                                                                                                                                                                                                                                                                                                property context

                                                                                                                                                                                                                                                                                                                                                                                context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                  property ssr

                                                                                                                                                                                                                                                                                                                                                                                  ssr?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                    interface BaseSubscriptionOptions

                                                                                                                                                                                                                                                                                                                                                                                    interface BaseSubscriptionOptions<
                                                                                                                                                                                                                                                                                                                                                                                    TData = any,
                                                                                                                                                                                                                                                                                                                                                                                    TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                                                                                                      property client

                                                                                                                                                                                                                                                                                                                                                                                      client?: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                        property context

                                                                                                                                                                                                                                                                                                                                                                                        context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                          property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                          fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                            property onComplete

                                                                                                                                                                                                                                                                                                                                                                                            onComplete?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                              property onData

                                                                                                                                                                                                                                                                                                                                                                                              onData?: (options: OnDataOptions<TData>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                property onError

                                                                                                                                                                                                                                                                                                                                                                                                onError?: (error: ApolloError) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  property onSubscriptionComplete

                                                                                                                                                                                                                                                                                                                                                                                                  onSubscriptionComplete?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                    property onSubscriptionData

                                                                                                                                                                                                                                                                                                                                                                                                    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any;

                                                                                                                                                                                                                                                                                                                                                                                                      property shouldResubscribe

                                                                                                                                                                                                                                                                                                                                                                                                      shouldResubscribe?:
                                                                                                                                                                                                                                                                                                                                                                                                      | boolean
                                                                                                                                                                                                                                                                                                                                                                                                      | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean);

                                                                                                                                                                                                                                                                                                                                                                                                        property skip

                                                                                                                                                                                                                                                                                                                                                                                                        skip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                          property variables

                                                                                                                                                                                                                                                                                                                                                                                                          variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                            interface Context

                                                                                                                                                                                                                                                                                                                                                                                                            interface DefaultContext extends Record<string, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                              interface DataProxy

                                                                                                                                                                                                                                                                                                                                                                                                              interface DataProxy {}

                                                                                                                                                                                                                                                                                                                                                                                                                method readFragment

                                                                                                                                                                                                                                                                                                                                                                                                                readFragment: <FragmentType, TVariables = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>,
                                                                                                                                                                                                                                                                                                                                                                                                                optimistic?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                ) => FragmentType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                  method readQuery

                                                                                                                                                                                                                                                                                                                                                                                                                  readQuery: <QueryType, TVariables = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                  options: DataProxy.ReadQueryOptions<QueryType, TVariables>,
                                                                                                                                                                                                                                                                                                                                                                                                                  optimistic?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => QueryType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                    method writeFragment

                                                                                                                                                                                                                                                                                                                                                                                                                    writeFragment: <TData = any, TVariables = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                    options: DataProxy.WriteFragmentOptions<TData, TVariables>
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Reference | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                      method writeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                      writeQuery: <TData = any, TVariables = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                      options: DataProxy.WriteQueryOptions<TData, TVariables>
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Reference | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface DefaultContext

                                                                                                                                                                                                                                                                                                                                                                                                                        interface DefaultContext extends Record<string, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          interface DefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                          interface DefaultOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property mutate

                                                                                                                                                                                                                                                                                                                                                                                                                            mutate?: Partial<MutationOptions<any, any, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                                                                                                                                                              query?: Partial<QueryOptions<any, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                property watchQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                watchQuery?: Partial<WatchQueryOptions<any, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ExecutionPatchIncrementalResult

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ExecutionPatchIncrementalResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                  TData = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                  TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                  > extends ExecutionPatchResultBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                    data?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                      errors?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                        extensions?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property incremental

                                                                                                                                                                                                                                                                                                                                                                                                                                          incremental?: IncrementalPayload<TData, TExtensions>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ExecutionPatchInitialResult

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ExecutionPatchInitialResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                            TData = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                            TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                            > extends ExecutionPatchResultBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                              data: TData | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                errors?: ReadonlyArray<GraphQLError>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                  extensions?: TExtensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property incremental

                                                                                                                                                                                                                                                                                                                                                                                                                                                    incremental?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FetchMoreOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property updateQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                        updateQuery?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        previousQueryResult: TData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        fetchMoreResult?: TData;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        variables?: TVariables;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => TData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FetchMoreQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FetchMoreQueryOptions<TVariables, TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                            context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                              query?: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                variables?: Partial<TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FieldFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FieldFunctionOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TArgs = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TVars = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: TArgs | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cache: InMemoryCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property canRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        canRead: CanReadFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          field: FieldNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fieldName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isReference: typeof isReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mergeObjects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mergeObjects: MergeObjectsFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property readField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readField: ReadFieldFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property storage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    storage: StorageType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property storeFieldName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      storeFieldName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property toReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toReference: ToReferenceFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variables?: TVars;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GraphQLRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GraphQLRequest<TVariables = Record<string, any>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extensions?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property operationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  operationName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HttpOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HttpOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          credentials?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fetch?: WindowOrWorkerGlobalScope['fetch'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fetchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fetchOptions?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                headers?: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property includeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includeExtensions?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property includeUnusedVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includeUnusedVariables?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property preserveHeaderCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preserveHeaderCase?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property print

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        print?: Printer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          uri?: string | UriFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property useGETForQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            useGETForQueries?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IdGetterObj

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IdGetterObj extends Object {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IDocumentDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IDocumentDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: DocumentType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variables: ReadonlyArray<VariableDefinitionNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IncrementalPayload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IncrementalPayload<TData, TExtensions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: TData | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              errors?: ReadonlyArray<GraphQLError>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extensions?: TExtensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InMemoryCacheConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InMemoryCacheConfig extends ApolloReducerConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fragments?: FragmentRegistryAPI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property possibleTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            possibleTypes?: PossibleTypesMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property resultCacheMaxSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resultCacheMaxSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property resultCaching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resultCaching?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typePolicies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typePolicies?: TypePolicies;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InternalRefetchQueriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extends Omit<RefetchQueriesOptions<TCache, TResult>, 'include'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      include?: InternalRefetchQueriesInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property removeOptimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeOptimistic?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LazyQueryHookOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LazyQueryHookOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > extends Omit<QueryHookOptions<TData, TVariables>, 'skip'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MergeInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MergeInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              field: FieldNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge: FieldMergeFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typename: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MergeTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MergeTree {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      info?: MergeInfo;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        map: Map<string | number, MergeTree>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MutationDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MutationDataOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > extends BaseMutationOptions<TData, TVariables, TContext, TCache> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MutationFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MutationFunctionOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends BaseMutationOptions<TData, TVariables, TContext, TCache> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MutationHookOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MutationHookOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > extends BaseMutationOptions<TData, TVariables, TContext, TCache> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MutationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MutationOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > extends MutationBaseOptions<TData, TVariables, TContext, TCache> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fetchPolicy?: MutationFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property keepRootFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepRootFields?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MutationResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MutationResult<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property called

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                called: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  client: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data?: TData | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error?: ApolloError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loading: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reset: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NormalizedCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NormalizedCache {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property canRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              canRead: CanReadFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getFieldValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getFieldValue: FieldValueGetter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property toReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toReference: ToReferenceFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      delete: (dataId: string, fieldName?: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        get: (dataId: string, fieldName: string) => StoreValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getStorage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getStorage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          idOrObj: string | StoreObject,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...storeFieldNames: (string | number)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => StorageType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            has: (dataId: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              merge: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (olderId: string, newerObject: StoreObject): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (olderObject: StoreObject, newerId: string): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method modify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                modify: (dataId: string, fields: Modifiers | Modifier<any>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method release

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  release: (rootId: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    replace: (newData: NormalizedCacheObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method retain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retain: (rootId: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toObject: () => NormalizedCacheObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NormalizedCacheObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NormalizedCacheObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [dataId: string]: StoreObject | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OnDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OnDataOptions<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                client: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: SubscriptionResult<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OnSubscriptionDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OnSubscriptionDataOptions<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      client: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property subscriptionData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        subscriptionData: SubscriptionResult<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Operation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extensions: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getContext: () => DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property operationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                operationName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setContext: (context: DefaultContext) => DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variables: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PureQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface QueryOptions<TVariables = OperationVariables, TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property errorPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              errorPolicy?: ErrorPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property notifyOnNetworkStatusChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notifyOnNetworkStatusChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property partialRefetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    partialRefetch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pollInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pollInterval?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property returnPartialData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          returnPartialData?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryDataOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends QueryFunctionOptions<TData, TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children?: (result: QueryResult<TData, TVariables>) => ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface QueryFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface QueryFunctionOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > extends BaseQueryOptions<TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onCompleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onCompleted?: (data: TData) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onError?: (error: ApolloError) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            skip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryHookOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryHookOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends QueryFunctionOptions<TData, TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query?: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface QueryLazyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface QueryLazyOptions<TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface QueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface QueryOptions<TVariables = OperationVariables, TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property errorPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              errorPolicy?: ErrorPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property notifyOnNetworkStatusChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notifyOnNetworkStatusChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property partialRefetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    partialRefetch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pollInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pollInterval?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property returnPartialData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          returnPartialData?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends ObservableQueryFields<TData, TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property called

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                called: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  client: ApolloClient<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: TData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error?: ApolloError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loading: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property networkStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          networkStatus: NetworkStatus;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property observable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            observable: ObservableQuery<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property previousData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousData?: TData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReactiveVar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReactiveVar<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method attachCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  attachCache: (cache: ApolloCache<any>) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method forgetCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forgetCache: (cache: ApolloCache<any>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onNextChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onNextChange: (listener: ReactiveListener<T>) => () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (newValue?: T): T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReadMergeModifyContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReadMergeModifyContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            store: NormalizedCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variables?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property varString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                varString?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Reference {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RefetchQueriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      include?: RefetchQueriesInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onQueryUpdated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onQueryUpdated?: OnQueryUpdated<TResult> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          optimistic?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property updateCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            updateCache?: (cache: TCache) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RefetchQueriesResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RefetchQueriesResult<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extends Promise<RefetchQueriesPromiseResults<TResult>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property queries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                queries: ObservableQuery<any>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property results

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  results: InternalRefetchQueriesResult<TResult>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Resolvers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Resolvers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [field: string]: Resolver;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SingleExecutionResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SingleExecutionResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TData = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > extends ExecutionResult<TData, TExtensions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context?: TContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data?: TData | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StoreObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StoreObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [storeFieldName: string]: StoreValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SubscriptionCurrentObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SubscriptionCurrentObservable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query?: Observable<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subscription?: ObservableSubscription;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SubscriptionDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SubscriptionDataOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > extends BaseSubscriptionOptions<TData, TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          children?: null | ((result: SubscriptionResult<TData>) => JSX.Element | null);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subscription: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SubscriptionHookOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SubscriptionHookOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends BaseSubscriptionOptions<TData, TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                subscription?: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SubscriptionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property errorPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      errorPolicy?: ErrorPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SubscriptionResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SubscriptionResult<TData = any, TVariables = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data?: TData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  error?: ApolloError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loading: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateQueryOptions<TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UriFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UriFunction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (operation: Operation): string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UseFragmentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UseFragmentOptions<TData, TVars>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Cache.DiffOptions<TData, TVars>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'id' | 'query' | 'optimistic' | 'previousResult'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Omit<Cache.ReadFragmentOptions<TData, TVars>, 'id'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from: StoreObject | Reference | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optimistic?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UseFragmentResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UseFragmentResult<TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property complete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        complete: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: TData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            missing?: MissingTree;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WatchQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WatchQueryOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends Omit<QueryOptions<TVariables, TData>, 'fetchPolicy'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchPolicy?: WatchQueryFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property initialFetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  initialFetchPolicy?: WatchQueryFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nextFetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextFetchPolicy?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | WatchQueryFetchPolicy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this: WatchQueryOptions<TVariables, TData>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    currentFetchPolicy: WatchQueryFetchPolicy,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context: NextFetchPolicyContext<TData, TVariables>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => WatchQueryFetchPolicy);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property refetchWritePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      refetchWritePolicy?: RefetchWritePolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DocumentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DocumentType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Query = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Mutation = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Subscription = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mutation = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Query = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Subscription = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum NetworkStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum NetworkStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loading = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setVariables = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchMore = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                refetch = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                poll = 6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ready = 7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                error = 8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  error = 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member fetchMore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fetchMore = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loading = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member poll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        poll = 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ready = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member refetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            refetch = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member setVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setVariables = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ApolloClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ApolloClientOptions<TCacheShape> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                uri?: string | UriFunction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                credentials?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                link?: ApolloLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cache: ApolloCache<TCacheShape>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ssrForceFetchDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ssrMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                connectToDevTools?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                queryDeduplication?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultOptions?: DefaultOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assumeImmutableResults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolvers?: Resolvers | Resolvers[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typeDefs?: string | string[] | DocumentNode | DocumentNode[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fragmentMatcher?: FragmentMatcher;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ApolloQueryResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ApolloQueryResult<T> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  errors?: ReadonlyArray<GraphQLError>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  error?: ApolloError;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loading: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  networkStatus: NetworkStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  partial?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ApolloReducerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ApolloReducerConfig = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dataIdFromObject?: KeyFieldsFunction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    addTypename?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ClientParseError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ClientParseError = InvariantError & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parseError: Error;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CommonOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CommonOptions<TOptions> = TOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        client?: ApolloClient<object>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DiffQueryAgainstStoreOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          returnPartialData?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ErrorPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ErrorPolicy = 'none' | 'ignore' | 'all';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ExecutionPatchResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ExecutionPatchResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ExecutionPatchInitialResult<TData, TExtensions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ExecutionPatchIncrementalResult<TData, TExtensions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FetchPolicy =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'cache-first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'network-only'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'cache-only'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'no-cache'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'standby';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FetchResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FetchResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TData = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SingleExecutionResult<TData, TContext, TExtensions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ExecutionPatchResult<TData, TExtensions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FieldMergeFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FieldMergeFunction<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TExisting = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIncoming = TExisting,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TOptions extends FieldFunctionOptions = FieldFunctionOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    existing: SafeReadonly<TExisting> | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    incoming: SafeReadonly<TIncoming>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: TOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => SafeReadonly<TExisting>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FieldPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FieldPolicy<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TExisting = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TIncoming = TExisting,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TReadResult = TIncoming,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TOptions extends FieldFunctionOptions = FieldFunctionOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keyArgs?: KeySpecifier | KeyArgsFunction | false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FieldReadFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FieldReadFunction<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TExisting = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TReadResult = TExisting,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TOptions extends FieldFunctionOptions = FieldFunctionOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        existing: SafeReadonly<TExisting> | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: TOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => TReadResult | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FragmentMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FragmentMatcher = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rootValue: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typeCondition: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IdGetter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IdGetter = (value: IdGetterObj) => string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InternalRefetchQueriesInclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InternalRefetchQueriesInclude =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | InternalRefetchQueryDescriptor[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | RefetchQueriesIncludeShorthand;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InternalRefetchQueriesMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InternalRefetchQueriesMap<TResult> = Map<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ObservableQuery<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InternalRefetchQueriesResult<TResult>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InternalRefetchQueriesResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InternalRefetchQueriesResult<TResult> = TResult extends boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ? Promise<ApolloQueryResult<any>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  : TResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InternalRefetchQueryDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LazyQueryExecFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LazyQueryExecFunction<TData, TVariables extends OperationVariables> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Partial<LazyQueryHookOptions<TData, TVariables>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<QueryResult<TData, TVariables>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LazyQueryResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LazyQueryResult<TData, TVariables extends OperationVariables> = QueryResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LazyQueryResultTuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LazyQueryResultTuple<TData, TVariables extends OperationVariables> = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LazyQueryExecFunction<TData, TVariables>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          QueryResult<TData, TVariables>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MutationFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MutationFunction<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<FetchResult<TData>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MutationQueryReducer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MutationQueryReducer<T> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousResult: Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mutationResult: FetchResult<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queryName: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queryVariables: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MutationQueryReducersMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MutationQueryReducersMap<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                T = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [queryName: string]: MutationQueryReducer<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MutationTuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MutationTuple<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TContext = DefaultContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TCache extends ApolloCache<any> = ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<FetchResult<TData>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MutationResult<TData>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MutationUpdaterFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MutationUpdaterFn<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    T = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > = (cache: ApolloCache<T>, mutationResult: FetchResult<T>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MutationUpdaterFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MutationUpdaterFunction<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TCache extends ApolloCache<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cache: TCache,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      result: Omit<FetchResult<TData>, 'context'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context?: TContext;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variables?: TVariables;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NextLink = (operation: Operation) => Observable<FetchResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ObservableQueryFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ObservableQuery<TData, TVariables>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'startPolling'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'stopPolling'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'subscribeToMore'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'updateQuery'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'refetch'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'reobserve'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'variables'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'fetchMore'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type OnQueryUpdated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type OnQueryUpdated<TResult> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            observableQuery: ObservableQuery<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff: Cache.DiffResult<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lastDiff: Cache.DiffResult<any> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean | TResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type OperationVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type OperationVariables = Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OptimisticStoreItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OptimisticStoreItem = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data: NormalizedCacheObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transaction: Transaction<NormalizedCacheObject>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Path = ReadonlyArray<string | number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PossibleTypesMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PossibleTypesMap = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [supertype: string]: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type QueryListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type QueryListener = (queryInfo: QueryInfo) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type QueryTuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type QueryTuple<TData, TVariables extends OperationVariables> = LazyQueryResultTuple<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReadQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReadQueryOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          store: NormalizedCache;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          query: DocumentNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variables?: Object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          previousResult?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          canonizeResults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rootId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: ApolloReducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RefetchQueriesFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RefetchQueriesFunction = (...args: any[]) => InternalRefetchQueriesInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RefetchQueriesInclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RefetchQueriesInclude =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | RefetchQueryDescriptor[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | RefetchQueriesIncludeShorthand;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RefetchQueriesPromiseResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : TResult extends boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? ApolloQueryResult<any>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : TResult extends PromiseLike<infer U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? U[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : TResult[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RefetchQueryDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RefetchQueryDescriptor = string | DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RequestHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RequestHandler = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    operation: Operation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forward: NextLink
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Observable<FetchResult> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Resolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Resolver = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rootValue?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      info?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      field: FieldNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fragmentMap: FragmentMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ServerError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ServerError = Error & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        response: Response;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        result: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        statusCode: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ServerParseError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ServerParseError = Error & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          response: Response;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          statusCode: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bodyText: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StoreValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StoreValue =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Reference
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Reference[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SubscribeToMoreOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SubscribeToMoreOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TSubscriptionVariables = OperationVariables,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TSubscriptionData = TData
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              document:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | DocumentNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variables?: TSubscriptionVariables;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onError?: (error: Error) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context?: DefaultContext;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Transaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Transaction<T> = (c: ApolloCache<T>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TypePolicies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TypePolicies = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [__typename: string]: TypePolicy;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TypePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TypePolicy = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keyFields?: KeySpecifier | KeyFieldsFunction | false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    merge?: FieldMergeFunction | boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    queryType?: true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mutationType?: true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    subscriptionType?: true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fields?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WatchQueryFetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WatchQueryFetchPolicy = FetchPolicy | 'cache-and-network';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace Cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace Cache {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface BatchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onWatchUpdated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onWatchUpdated?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: TCache,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            watch: Cache.WatchOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff: Cache.DiffResult<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lastDiff: Cache.DiffResult<any> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              optimistic?: string | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property removeOptimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeOptimistic?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  update: (cache: TCache) => TUpdateResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DiffOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DiffOptions<TData = any, TVariables = any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extends Omit<ReadOptions<TVariables, TData>, 'rootId'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EvictOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EvictOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property broadcast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          broadcast?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fieldName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ModifyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ModifyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property broadcast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  broadcast?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fields: Modifiers | Modifier<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optimistic?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReadOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReadOptions<TVariables = any, TData = any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extends DataProxy.Query<TVariables, TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              optimistic: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property previousResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                previousResult?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property returnPartialData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  returnPartialData?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rootId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rootId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ResetOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ResetOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property discardWatches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        discardWatches?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface WatchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface WatchOptions<TData = any, TVariables = any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extends DiffOptions<TData, TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: WatchCallback<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property