@apollo/client

  • Version 3.6.9
  • Published
  • 4.13 MB
  • 12 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 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;

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

                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                          readonly message: string;

                                                                                                                                                                                                                                                                                            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>) => boolean;

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

                                                                                                                                                                                                                                                                                                                                                                  property onError

                                                                                                                                                                                                                                                                                                                                                                  onError?: (error: ApolloError) => 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 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 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 FetchResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                              property context

                                                                                                                                                                                                                                                                                                                                                                                                                              context?: TContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                data?: TData | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                  extensions?: TExtensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                    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 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 InMemoryCacheConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface InMemoryCacheConfig extends ApolloReducerConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 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 displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    displayName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 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 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 FetchPolicy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 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 ReadOptions<TVariables, TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 ReadOptions<TVariables, TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type WatchCallback<TData = any> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff: Cache.DiffResult<TData>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lastDiff?: Cache.DiffResult<TData>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace DataProxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace DataProxy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Fragment<TVariables, TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fragment: