@apollo/client

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

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

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

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

gc: () => string[];

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

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

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

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

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

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

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

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

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

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

transformDocument: (document: DocumentNode) => DocumentNode;

transformForLink: (document: DocumentNode) => DocumentNode;

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

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

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

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

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

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

constructor(options: ApolloClientOptions<TCacheShape>);

cache: ApolloCache<TCacheShape>;

defaultOptions: DefaultOptions;

disableNetworkFetches: boolean;

link: ApolloLink;

queryDeduplication: boolean;

readonly typeDefs: any;

version: string;

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

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

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

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

getResolvers: () => Resolvers;

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

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

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

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

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

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

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

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

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

restore: (serializedState: TCacheShape) => ApolloCache<TCacheShape>;

setLink: (newLink: ApolloLink) => void;

setLocalStateFragmentMatcher: (fragmentMatcher: FragmentMatcher) => void;

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

stop: () => void;

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

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

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

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

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

clientErrors: readonly Error[];

extraInfo: any;

graphQLErrors: GraphQLErrors;

message: string;

name: string;

networkError: Error | ServerParseError | ServerError;

constructor(request?: RequestHandler);

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

static empty: () => ApolloLink;

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

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

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

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

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

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

constructor(options?: HttpOptions);

options: HttpOptions;

requester: RequestHandler;

constructor(config?: InMemoryCacheConfig);

protected config: InMemoryCacheConfig;

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

readonly policies: Policies;

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

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

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

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

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

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

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

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

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

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

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

removeOptimistic: (idToRemove: string) => void;

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

restore: (data: NormalizedCacheObject) => this;

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

transformDocument: (document: DocumentNode) => DocumentNode;

transformForLink: (document: DocumentNode) => DocumentNode;

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

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

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

readonly message: string;

readonly missing: MissingTree;

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

readonly query: DocumentNode;

readonly variables?: Record<string, any>;

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

readonly options: WatchQueryOptions<TVariables, TData>;

readonly query: TypedDocumentNode<TData, TVariables>;

readonly queryId: string;

readonly queryName?: string;

readonly variables: OperationVariables;

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

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

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

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

hasObservers: () => boolean;

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

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

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

resetLastResults: () => void;

resetQueryStoreErrors: () => void;

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

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

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

startPolling: (pollInterval: number) => void;

stopPolling: () => void;

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

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

client?: ApolloClient<object>;

renderPromises?: RenderPromises;