@apollo/client

  • Version 3.7.1
  • Published
  • 4.39 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
            ) => 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 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, TVars>(
                                                                    options: UseFragmentOptions<TData, TVars>
                                                                    ) => UseFragmentResult<TData>;

                                                                      function useLazyQuery

                                                                      useLazyQuery: <TData = any, TVariables = 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>
                                                                        ) => MutationTuple<TData, TVariables, TContext, TCache>;

                                                                          function useQuery

                                                                          useQuery: <TData = any, TVariables = 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 = 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 = OperationVariables,
                                                                                                                                                            TContext = 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 = 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 = OperationVariables>(
                                                                                                                                                                                        options: SubscriptionOptions<TVariables, T>
                                                                                                                                                                                        ) => Observable<FetchResult<T, Record<string, any>, Record<string, any>>>;

                                                                                                                                                                                          method watchQuery

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

                                                                                                                                                                                            method writeFragment

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

                                                                                                                                                                                              method writeQuery

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

                                                                                                                                                                                                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 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 = 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 = 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: {};

                                                                                                                                                                                                                                                                                                                      method fetchMore

                                                                                                                                                                                                                                                                                                                      fetchMore: <TFetchData = TData, TFetchVars = 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 = TVariables
                                                                                                                                                                                                                                                                                                                                                    >(
                                                                                                                                                                                                                                                                                                                                                    options: SubscribeToMoreOptions<
                                                                                                                                                                                                                                                                                                                                                    TData,
                                                                                                                                                                                                                                                                                                                                                    TSubscriptionVariables,
                                                                                                                                                                                                                                                                                                                                                    TSubscriptionData
                                                                                                                                                                                                                                                                                                                                                    >
                                                                                                                                                                                                                                                                                                                                                    ) => () => void;

                                                                                                                                                                                                                                                                                                                                                      method updateQuery

                                                                                                                                                                                                                                                                                                                                                      updateQuery: <TVars = 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 = 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 = 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 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>
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  method writeQuery

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

                                                                                                                                                                                                                                                                                                                                                                                                                    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: Data<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          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?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        context?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extensions?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property operationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            operationName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variables?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface HttpOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface HttpOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    credentials?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fetch?: WindowOrWorkerGlobalScope['fetch'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fetchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fetchOptions?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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: Data<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 = 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: () => Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property operationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          operationName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setContext: (context: Record<string, any>) => Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variables: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PureQueryOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 = 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 = 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 = 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?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 = 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 = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > extends ExecutionResult<TData, TExtensions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context?: TContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data?: Data<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 = 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 = 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 = 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 Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DefaultContext = Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DefaultContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DefaultContext = Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: Partial<LazyQueryHookOptions<TData, TVariables>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<QueryResult<TData, TVariables>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LazyQueryResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LazyQueryResultTuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LazyQueryResultTuple<TData, TVariables> = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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> = 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> = 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 immediate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            immediate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lastDiff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lastDiff?: DiffResult<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property watcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                watcher?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WriteOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WriteOptions<TResult = any, TVariables = any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extends Omit<DataProxy.Query<TVariables, TResult>, 'id'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Omit<DataProxy.WriteOptions<TResult>, 'data'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property dataId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dataId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      result: TResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WatchCallback