@apollo/client

  • Version 3.8.4
  • Published
  • 5.27 MB
  • 13 dependencies
  • MIT license

Install

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

Overview

A fully-featured caching GraphQL client.

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ApolloConsumer

const ApolloConsumer: React.FC<ApolloConsumerProps>;

    variable ApolloProvider

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

      variable concat

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

        variable defaultPrinter

        const defaultPrinter: Printer;

          variable empty

          const empty: () => ApolloLink;

            variable execute

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

              variable fallbackHttpConfig

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

                variable from

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

                  variable resetApolloContext

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

                    variable skipToken

                    const skipToken: Symbol;

                      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 isNetworkRequestSettled

                                        isNetworkRequestSettled: (networkStatus?: NetworkStatus) => boolean;

                                          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: <
                                                TDefaultOptions extends Partial<OptionsUnion<any, any, any>>,
                                                TOptions extends TDefaultOptions
                                                >(
                                                defaults: TDefaultOptions | Partial<TDefaultOptions> | undefined,
                                                options: TOptions | Partial<TOptions>
                                                ) => TOptions & TDefaultOptions;

                                                  function operationName

                                                  operationName: (type: DocumentType) => string;

                                                    function parseAndCheckHttpResponse

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

                                                      function parser

                                                      parser: (document: DocumentNode) => IDocumentDefinition;

                                                        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 useBackgroundQuery

                                                                        useBackgroundQuery: {
                                                                        <
                                                                        TData,
                                                                        TVariables extends OperationVariables,
                                                                        TOptions extends Omit<
                                                                        BackgroundQueryHookOptions<TData, OperationVariables>,
                                                                        'variables'
                                                                        >
                                                                        >(
                                                                        query: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                        options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & TOptions
                                                                        ): [
                                                                        (
                                                                        | QueryReference<
                                                                        TOptions['errorPolicy'] extends 'ignore' | 'all'
                                                                        ? TOptions['returnPartialData'] extends true
                                                                        ? DeepPartial<TData> | undefined
                                                                        : TData | undefined
                                                                        : TOptions['returnPartialData'] extends true
                                                                        ? DeepPartial<TData>
                                                                        : TData
                                                                        >
                                                                        | (TOptions['skip'] extends boolean ? undefined : never)
                                                                        ),
                                                                        UseBackgroundQueryResult<TData, TVariables>
                                                                        ];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
                                                                        returnPartialData: true;
                                                                        errorPolicy: 'all' | 'ignore';
                                                                        }
                                                                        ): [
                                                                        QueryReference<DeepPartial<TData>>,
                                                                        UseBackgroundQueryResult<TData, TVariables>
                                                                        ];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
                                                                        errorPolicy: 'all' | 'ignore';
                                                                        }
                                                                        ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
                                                                        skip: boolean;
                                                                        returnPartialData: true;
                                                                        }
                                                                        ): [
                                                                        QueryReference<DeepPartial<TData>>,
                                                                        UseBackgroundQueryResult<TData, TVariables>
                                                                        ];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
                                                                        returnPartialData: true;
                                                                        }
                                                                        ): [
                                                                        QueryReference<DeepPartial<TData>>,
                                                                        UseBackgroundQueryResult<TData, TVariables>
                                                                        ];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
                                                                        skip: boolean;
                                                                        }
                                                                        ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables>
                                                                        ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options: typeof skipToken
                                                                        ): [undefined, UseBackgroundQueryResult<TData, TVariables>];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options:
                                                                        | typeof skipToken
                                                                        | (BackgroundQueryHookOptionsNoInfer<TData, TVariables> & {
                                                                        returnPartialData: true;
                                                                        })
                                                                        ): [
                                                                        QueryReference<DeepPartial<TData>>,
                                                                        UseBackgroundQueryResult<TData, TVariables>
                                                                        ];
                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                        query: any,
                                                                        options?:
                                                                        | typeof skipToken
                                                                        | BackgroundQueryHookOptionsNoInfer<TData, TVariables>
                                                                        ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];
                                                                        };

                                                                          function useFragment

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

                                                                            function useLazyQuery

                                                                            useLazyQuery: <
                                                                            TData = any,
                                                                            TVariables extends OperationVariables = OperationVariables
                                                                            >(
                                                                            query: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                            options?: LazyQueryHookOptions<NoInfer<TData>, NoInfer<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<
                                                                              NoInfer<TData>,
                                                                              NoInfer<TVariables>,
                                                                              TContext,
                                                                              TCache
                                                                              >
                                                                              ) => MutationTuple<TData, TVariables, TContext, TCache>;

                                                                                function useQuery

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

                                                                                  function useReactiveVar

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

                                                                                    function useReadQuery

                                                                                    useReadQuery: <TData>(queryRef: QueryReference<TData>) => {
                                                                                    data: TData;
                                                                                    networkStatus: import('../../index.js').NetworkStatus;
                                                                                    error: import('../../index.js').ApolloError | undefined;
                                                                                    };

                                                                                      function useSubscription

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

                                                                                        function useSuspenseQuery

                                                                                        useSuspenseQuery: {
                                                                                        <
                                                                                        TData,
                                                                                        TVariables extends OperationVariables,
                                                                                        TOptions extends Omit<
                                                                                        SuspenseQueryHookOptions<TData, OperationVariables>,
                                                                                        'variables'
                                                                                        >
                                                                                        >(
                                                                                        query: DocumentNode | TypedDocumentNode<TData, TVariables>,
                                                                                        options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> &
                                                                                        TOptions
                                                                                        ): UseSuspenseQueryResult<
                                                                                        TOptions['errorPolicy'] extends 'ignore' | 'all'
                                                                                        ? TOptions['returnPartialData'] extends true
                                                                                        ? DeepPartial<TData> | undefined
                                                                                        : TData | undefined
                                                                                        : TOptions['returnPartialData'] extends true
                                                                                        ? TOptions['skip'] extends boolean
                                                                                        ? DeepPartial<TData> | undefined
                                                                                        : DeepPartial<TData>
                                                                                        : TOptions['skip'] extends boolean
                                                                                        ? TData | undefined
                                                                                        : TData,
                                                                                        TVariables
                                                                                        >;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
                                                                                        returnPartialData: true;
                                                                                        errorPolicy: 'all' | 'ignore';
                                                                                        }
                                                                                        ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
                                                                                        errorPolicy: 'all' | 'ignore';
                                                                                        }
                                                                                        ): UseSuspenseQueryResult<TData, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
                                                                                        skip: boolean;
                                                                                        returnPartialData: true;
                                                                                        }
                                                                                        ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
                                                                                        returnPartialData: true;
                                                                                        }
                                                                                        ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
                                                                                        skip: boolean;
                                                                                        }
                                                                                        ): UseSuspenseQueryResult<TData, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>
                                                                                        ): UseSuspenseQueryResult<TData, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options:
                                                                                        | typeof skipToken
                                                                                        | (SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & {
                                                                                        returnPartialData: true;
                                                                                        })
                                                                                        ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>;
                                                                                        <TData = unknown, TVariables extends OperationVariables = OperationVariables>(
                                                                                        query: any,
                                                                                        options?:
                                                                                        | typeof skipToken
                                                                                        | SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>
                                                                                        ): UseSuspenseQueryResult<TData, TVariables>;
                                                                                        };

                                                                                          Classes

                                                                                          class ApolloCache

                                                                                          abstract class ApolloCache<TSerialized> implements DataProxy {}

                                                                                            property assumeImmutableResults

                                                                                            readonly assumeImmutableResults: boolean;

                                                                                              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: <Entity extends Record<string, any> = Record<string, any>>(
                                                                                                          options: Cache.ModifyOptions<Entity>
                                                                                                          ) => 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;

                                                                                                                                                      property documentTransform

                                                                                                                                                      readonly documentTransform: DocumentTransform;
                                                                                                                                                        link: ApolloLink;

                                                                                                                                                          property queryDeduplication

                                                                                                                                                          queryDeduplication: boolean;

                                                                                                                                                            property typeDefs

                                                                                                                                                            readonly typeDefs: any;

                                                                                                                                                              property version

                                                                                                                                                              version: string;

                                                                                                                                                                method addResolvers

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

                                                                                                                                                                  method clearStore

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

                                                                                                                                                                    method extract

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

                                                                                                                                                                      method getObservableQueries

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

                                                                                                                                                                        method getResolvers

                                                                                                                                                                        getResolvers: () => Resolvers;

                                                                                                                                                                          method mutate

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

                                                                                                                                                                            method onClearStore

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

                                                                                                                                                                              method onResetStore

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

                                                                                                                                                                                method query

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

                                                                                                                                                                                  method readFragment

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

                                                                                                                                                                                    method readQuery

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

                                                                                                                                                                                      method reFetchObservableQueries

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

                                                                                                                                                                                        method refetchQueries

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

                                                                                                                                                                                          method resetStore

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

                                                                                                                                                                                            method restore

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

                                                                                                                                                                                                method setLocalStateFragmentMatcher

                                                                                                                                                                                                setLocalStateFragmentMatcher: (fragmentMatcher: FragmentMatcher) => void;

                                                                                                                                                                                                  method setResolvers

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

                                                                                                                                                                                                    method stop

                                                                                                                                                                                                    stop: () => void;

                                                                                                                                                                                                      method subscribe

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

                                                                                                                                                                                                        method watchQuery

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

                                                                                                                                                                                                          method writeFragment

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

                                                                                                                                                                                                            method writeQuery

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

                                                                                                                                                                                                              class ApolloError

                                                                                                                                                                                                              class ApolloError extends Error {}

                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                constructor({
                                                                                                                                                                                                                graphQLErrors,
                                                                                                                                                                                                                protocolErrors,
                                                                                                                                                                                                                clientErrors,
                                                                                                                                                                                                                networkError,
                                                                                                                                                                                                                errorMessage,
                                                                                                                                                                                                                extraInfo,
                                                                                                                                                                                                                }: ApolloErrorOptions);

                                                                                                                                                                                                                  property clientErrors

                                                                                                                                                                                                                  clientErrors: readonly Error[];

                                                                                                                                                                                                                    property extraInfo

                                                                                                                                                                                                                    extraInfo: any;

                                                                                                                                                                                                                      property graphQLErrors

                                                                                                                                                                                                                      graphQLErrors: GraphQLErrors;

                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                        message: string;

                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                            property networkError

                                                                                                                                                                                                                            networkError: Error | ServerParseError | ServerError;

                                                                                                                                                                                                                              property protocolErrors

                                                                                                                                                                                                                              protocolErrors: readonly {
                                                                                                                                                                                                                              message: string;
                                                                                                                                                                                                                              extensions?: GraphQLErrorExtensions[];
                                                                                                                                                                                                                              }[];
                                                                                                                                                                                                                                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 DocumentTransform

                                                                                                                                                                                                                                                    class DocumentTransform {}

                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                      constructor(transform: TransformFn, options?: DocumentTransformOptions);

                                                                                                                                                                                                                                                        method concat

                                                                                                                                                                                                                                                        concat: (otherTransform: DocumentTransform) => DocumentTransform;

                                                                                                                                                                                                                                                          method getStableCacheEntry

                                                                                                                                                                                                                                                          getStableCacheEntry: (
                                                                                                                                                                                                                                                          document: DocumentNode
                                                                                                                                                                                                                                                          ) =>
                                                                                                                                                                                                                                                          | { key: DocumentTransformCacheKey; value?: DocumentNode | undefined }
                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                            method identity

                                                                                                                                                                                                                                                            static identity: () => DocumentTransform;

                                                                                                                                                                                                                                                              method split

                                                                                                                                                                                                                                                              static split: (
                                                                                                                                                                                                                                                              predicate: (document: DocumentNode) => boolean,
                                                                                                                                                                                                                                                              left: DocumentTransform,
                                                                                                                                                                                                                                                              right?: DocumentTransform
                                                                                                                                                                                                                                                              ) => DocumentTransform;

                                                                                                                                                                                                                                                                method transformDocument

                                                                                                                                                                                                                                                                transformDocument: (document: DocumentNode) => DocumentNode;
                                                                                                                                                                                                                                                                  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 assumeImmutableResults

                                                                                                                                                                                                                                                                              readonly assumeImmutableResults: boolean;

                                                                                                                                                                                                                                                                                property config

                                                                                                                                                                                                                                                                                protected config: InMemoryCacheConfig;

                                                                                                                                                                                                                                                                                  property makeVar

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

                                                                                                                                                                                                                                                                                    property policies

                                                                                                                                                                                                                                                                                    readonly policies: Policies;

                                                                                                                                                                                                                                                                                      method batch

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

                                                                                                                                                                                                                                                                                        method broadcastWatches

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

                                                                                                                                                                                                                                                                                          method diff

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

                                                                                                                                                                                                                                                                                            method evict

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

                                                                                                                                                                                                                                                                                              method extract

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

                                                                                                                                                                                                                                                                                                method gc

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

                                                                                                                                                                                                                                                                                                  method identify

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

                                                                                                                                                                                                                                                                                                    method modify

                                                                                                                                                                                                                                                                                                    modify: <Entity extends Record<string, any> = Record<string, any>>(
                                                                                                                                                                                                                                                                                                    options: Cache.ModifyOptions<Entity>
                                                                                                                                                                                                                                                                                                    ) => 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 extends Error {}

                                                                                                                                                                                                                                                                                                                            constructor

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

                                                                                                                                                                                                                                                                                                                              property message

                                                                                                                                                                                                                                                                                                                              readonly message: string;

                                                                                                                                                                                                                                                                                                                                property missing

                                                                                                                                                                                                                                                                                                                                readonly missing: MissingTree;

                                                                                                                                                                                                                                                                                                                                  property path

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

                                                                                                                                                                                                                                                                                                                                    property query

                                                                                                                                                                                                                                                                                                                                    readonly query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                                      readonly variables?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                        class ObservableQuery

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

                                                                                                                                                                                                                                                                                                                                          constructor

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

                                                                                                                                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                                                                                                                                            readonly options: WatchQueryOptions<TVariables, TData>;

                                                                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                                                                              readonly query: TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                property queryId

                                                                                                                                                                                                                                                                                                                                                readonly queryId: string;

                                                                                                                                                                                                                                                                                                                                                  property queryName

                                                                                                                                                                                                                                                                                                                                                  readonly queryName?: string;

                                                                                                                                                                                                                                                                                                                                                    property variables

                                                                                                                                                                                                                                                                                                                                                    readonly variables: OperationVariables;

                                                                                                                                                                                                                                                                                                                                                      method fetchMore

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

                                                                                                                                                                                                                                                                                                                                                        method getCurrentResult

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

                                                                                                                                                                                                                                                                                                                                                          method getLastError

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

                                                                                                                                                                                                                                                                                                                                                            method getLastResult

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

                                                                                                                                                                                                                                                                                                                                                              method hasObservers

                                                                                                                                                                                                                                                                                                                                                              hasObservers: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                method isDifferentFromLastResult

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

                                                                                                                                                                                                                                                                                                                                                                  method refetch

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

                                                                                                                                                                                                                                                                                                                                                                    method reobserve

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

                                                                                                                                                                                                                                                                                                                                                                      method reobserveAsConcast

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

                                                                                                                                                                                                                                                                                                                                                                        method resetLastResults

                                                                                                                                                                                                                                                                                                                                                                        resetLastResults: () => void;

                                                                                                                                                                                                                                                                                                                                                                          method resetQueryStoreErrors

                                                                                                                                                                                                                                                                                                                                                                          resetQueryStoreErrors: () => void;

                                                                                                                                                                                                                                                                                                                                                                            method resubscribeAfterError

                                                                                                                                                                                                                                                                                                                                                                            resubscribeAfterError: {
                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                            onNext: (value: ApolloQueryResult<TData>) => void,
                                                                                                                                                                                                                                                                                                                                                                            onError?: (error: any) => void,
                                                                                                                                                                                                                                                                                                                                                                            onComplete?: () => void
                                                                                                                                                                                                                                                                                                                                                                            ): ObservableSubscription;
                                                                                                                                                                                                                                                                                                                                                                            (observer: Observer<ApolloQueryResult<TData>>): ObservableSubscription;
                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                              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 silentSetOptions

                                                                                                                                                                                                                                                                                                                                                                                    silentSetOptions: (
                                                                                                                                                                                                                                                                                                                                                                                    newOptions: Partial<WatchQueryOptions<TVariables, TData>>
                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                      method startPolling

                                                                                                                                                                                                                                                                                                                                                                                      startPolling: (pollInterval: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method stopPolling

                                                                                                                                                                                                                                                                                                                                                                                        stopPolling: () => void;

                                                                                                                                                                                                                                                                                                                                                                                          method subscribeToMore

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

                                                                                                                                                                                                                                                                                                                                                                                            method updateQuery

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

                                                                                                                                                                                                                                                                                                                                                                                              class SuspenseCache

                                                                                                                                                                                                                                                                                                                                                                                              class SuspenseCache extends RealSuspenseCache {}

                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                constructor();

                                                                                                                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                  interface ApolloContextValue

                                                                                                                                                                                                                                                                                                                                                                                                  interface ApolloContextValue {}

                                                                                                                                                                                                                                                                                                                                                                                                    property client

                                                                                                                                                                                                                                                                                                                                                                                                    client?: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                      property renderPromises

                                                                                                                                                                                                                                                                                                                                                                                                      renderPromises?: RenderPromises;

                                                                                                                                                                                                                                                                                                                                                                                                        interface ApolloPayloadResult

                                                                                                                                                                                                                                                                                                                                                                                                        interface ApolloPayloadResult<
                                                                                                                                                                                                                                                                                                                                                                                                        TData = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                        TExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                                                                                                                                                                                          property errors

                                                                                                                                                                                                                                                                                                                                                                                                          errors?: ReadonlyArray<Error | string>;

                                                                                                                                                                                                                                                                                                                                                                                                            property payload

                                                                                                                                                                                                                                                                                                                                                                                                            payload: SingleExecutionResult | ExecutionPatchResult | null;

                                                                                                                                                                                                                                                                                                                                                                                                              interface BackgroundQueryHookOptions

                                                                                                                                                                                                                                                                                                                                                                                                              interface BackgroundQueryHookOptions<
                                                                                                                                                                                                                                                                                                                                                                                                              TData = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                              > extends Pick<
                                                                                                                                                                                                                                                                                                                                                                                                              QueryHookOptions<TData, TVariables>,
                                                                                                                                                                                                                                                                                                                                                                                                              | 'client'
                                                                                                                                                                                                                                                                                                                                                                                                              | 'variables'
                                                                                                                                                                                                                                                                                                                                                                                                              | 'errorPolicy'
                                                                                                                                                                                                                                                                                                                                                                                                              | 'context'
                                                                                                                                                                                                                                                                                                                                                                                                              | 'canonizeResults'
                                                                                                                                                                                                                                                                                                                                                                                                              | 'returnPartialData'
                                                                                                                                                                                                                                                                                                                                                                                                              | 'refetchWritePolicy'
                                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                                property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                fetchPolicy?: BackgroundQueryHookFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                  property queryKey

                                                                                                                                                                                                                                                                                                                                                                                                                  queryKey?: string | number | any[];

                                                                                                                                                                                                                                                                                                                                                                                                                    property skip

                                                                                                                                                                                                                                                                                                                                                                                                                    skip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                      property suspenseCache

                                                                                                                                                                                                                                                                                                                                                                                                                      suspenseCache?: SuspenseCache;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface BaseMutationOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                          property client

                                                                                                                                                                                                                                                                                                                                                                                                                          client?: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                            property ignoreResults

                                                                                                                                                                                                                                                                                                                                                                                                                            ignoreResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                              property notifyOnNetworkStatusChange

                                                                                                                                                                                                                                                                                                                                                                                                                              notifyOnNetworkStatusChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                property onCompleted

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

                                                                                                                                                                                                                                                                                                                                                                                                                                  property onError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BaseQueryOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      property client

                                                                                                                                                                                                                                                                                                                                                                                                                                      client?: ApolloClient<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property context

                                                                                                                                                                                                                                                                                                                                                                                                                                        context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property ssr

                                                                                                                                                                                                                                                                                                                                                                                                                                          ssr?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface BaseSubscriptionOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              property client

                                                                                                                                                                                                                                                                                                                                                                                                                                              client?: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                  fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                    onComplete?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onData

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onSubscriptionComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                          onSubscriptionComplete?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onSubscriptionData

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property shouldResubscribe

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                skip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DefaultContext extends Record<string, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DataProxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DataProxy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method readFragment

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method readQuery

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method writeFragment

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method writeQuery

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DefaultContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DefaultContext extends Record<string, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DefaultOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mutate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property query

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property watchQuery

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DefaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DefaultOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property react

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            react?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            suspense?: Readonly<SuspenseCacheOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ExecutionPatchIncrementalResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  errors?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extensions?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property incremental

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ExecutionPatchInitialResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: TData | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errors?: ReadonlyArray<GraphQLError>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extensions?: TExtensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property incremental

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                incremental?: never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FetchMoreOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property updateQuery

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FetchMoreQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FetchMoreQueryOptions<TVariables, TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property query

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variables?: Partial<TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FieldFunctionOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: TArgs | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cache: InMemoryCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property canRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    canRead: CanReadFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      field: FieldNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fieldName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fieldName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isReference: typeof isReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mergeObjects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mergeObjects: MergeObjectsFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property readField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readField: ReadFieldFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property storage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                storage: StorageType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property storeFieldName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  storeFieldName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property toReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toReference: ToReferenceFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variables?: TVars;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GraphQLRequest

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extensions?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property operationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operationName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HttpOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HttpOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      credentials?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fetch?: WindowOrWorkerGlobalScope['fetch'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fetchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fetchOptions?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            headers?: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property includeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeExtensions?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property includeUnusedVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includeUnusedVariables?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property preserveHeaderCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  preserveHeaderCase?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property print

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    print?: Printer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      uri?: string | UriFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property useGETForQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        useGETForQueries?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IdGetterObj

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IdGetterObj extends Object {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IDocumentDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IDocumentDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: DocumentType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variables: ReadonlyArray<VariableDefinitionNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IncrementalPayload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IncrementalPayload<TData, TExtensions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: TData | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          errors?: ReadonlyArray<GraphQLError>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extensions?: TExtensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InMemoryCacheConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InMemoryCacheConfig extends ApolloReducerConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fragments?: FragmentRegistryAPI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property possibleTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        possibleTypes?: PossibleTypesMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property resultCacheMaxSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resultCacheMaxSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resultCaching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resultCaching?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property typePolicies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typePolicies?: TypePolicies;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface InternalRefetchQueriesOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  include?: InternalRefetchQueriesInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property removeOptimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeOptimistic?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LazyQueryHookExecOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property query

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LazyQueryHookOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MergeInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MergeInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              field: FieldNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge: FieldMergeFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typename: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MergeTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MergeTree {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      info?: MergeInfo;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        map: Map<string | number, MergeTree>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MutationDataOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MutationFunctionOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mutation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MutationHookOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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: <Entity extends Record<string, any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dataId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fields: Modifiers<Entity> | AllFieldsModifier<Entity>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method release

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                release: (rootId: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  replace: (newData: NormalizedCacheObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method retain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    retain: (rootId: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toObject: () => NormalizedCacheObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NormalizedCacheObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NormalizedCacheObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [dataId: string]: StoreObject | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OnDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OnDataOptions<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              client: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data: SubscriptionResult<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OnSubscriptionDataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OnSubscriptionDataOptions<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    client: ApolloClient<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property subscriptionData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subscriptionData: SubscriptionResult<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Operation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extensions: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getContext: () => DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property operationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operationName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setContext: (context: DefaultContext) => DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variables: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PureQueryOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property errorPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errorPolicy?: ErrorPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property notifyOnNetworkStatusChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notifyOnNetworkStatusChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property partialRefetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  partialRefetch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pollInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pollInterval?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property returnPartialData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        returnPartialData?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface QueryDataOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property children

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface QueryFunctionOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onCompleted

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          skip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface QueryHookOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryLazyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryLazyOptions<TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface QueryOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property canonizeResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      canonizeResults?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        context?: DefaultContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property errorPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          errorPolicy?: ErrorPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fetchPolicy?: FetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property notifyOnNetworkStatusChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              notifyOnNetworkStatusChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property partialRefetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                partialRefetch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pollInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pollInterval?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property returnPartialData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      returnPartialData?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface QueryReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface QueryReference<TData = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property [QUERY_REFERENCE_SYMBOL]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface QueryResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property called

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                called: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  client: ApolloClient<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: TData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error?: ApolloError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loading: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property networkStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          networkStatus: NetworkStatus;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property observable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            observable: ObservableQuery<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property previousData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousData?: TData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReactiveVar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReactiveVar<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method attachCache

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method forgetCache

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onNextChange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (newValue?: T): T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReadMergeModifyContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReadMergeModifyContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            store: NormalizedCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variables?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property varString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                varString?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Reference {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RefetchQueriesOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      include?: RefetchQueriesInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onQueryUpdated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onQueryUpdated?: OnQueryUpdated<TResult> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          optimistic?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property updateCache

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RefetchQueriesResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property queries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                queries: ObservableQuery<any>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property results

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  results: InternalRefetchQueriesResult<TResult>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Resolvers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Resolvers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SingleExecutionResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context?: TContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data?: TData | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StoreObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StoreObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [storeFieldName: string]: StoreValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SubscriptionCurrentObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SubscriptionCurrentObservable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query?: Observable<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subscription?: ObservableSubscription;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SubscriptionDataOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property children

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subscription: DocumentNode | TypedDocumentNode<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SubscriptionHookOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 SuspenseQueryHookOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SuspenseQueryHookOptions<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TData = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > extends Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      QueryHookOptions<TData, TVariables>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'client'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'variables'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'errorPolicy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'context'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'canonizeResults'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'returnPartialData'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'refetchWritePolicy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fetchPolicy?: SuspenseQueryHookFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property queryKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          queryKey?: string | number | any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            skip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property suspenseCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              suspenseCache?: SuspenseCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UpdateQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UpdateQueryOptions<TVariables> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variables?: TVariables;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UriFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UriFunction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (operation: Operation): string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UseFragmentOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          from: StoreObject | Reference | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property optimistic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            optimistic?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface UseSuspenseQueryResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface UseSuspenseQueryResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TData = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TVariables extends OperationVariables = OperationVariables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                client: ApolloClient<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: TData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    error: ApolloError | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fetchMore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fetchMore: FetchMoreFunction<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property networkStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        networkStatus: NetworkStatus;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property refetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          refetch: RefetchFunction<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property subscribeToMore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WatchQueryOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchPolicy?: WatchQueryFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property initialFetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  initialFetchPolicy?: WatchQueryFetchPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nextFetchPolicy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property refetchWritePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      refetchWritePolicy?: RefetchWritePolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DocumentType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Mutation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mutation = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Query = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Subscription = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum NetworkStatus

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  error = 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member fetchMore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fetchMore = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loading = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member poll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        poll = 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ready = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member refetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            refetch = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member setVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setVariables = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ApolloClientOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 BackgroundQueryHookFetchPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BackgroundQueryHookFetchPolicy = Extract<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WatchQueryFetchPolicy,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'cache-first' | 'network-only' | 'no-cache' | 'cache-and-network'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ClientParseError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CommonOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DiffQueryAgainstStoreOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DocumentTransformCacheKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DocumentTransformCacheKey = ReadonlyArray<unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ErrorPolicy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ExecutionPatchResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FetchPolicy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FetchResult

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