apollo-client

constructor(options: ApolloClientOptions<TCacheShape>);

cache: ApolloCache<TCacheShape>;

defaultOptions: DefaultOptions;

disableNetworkFetches: boolean;

link: ApolloLink;

queryDeduplication: boolean;

readonly queryManager: QueryManager<TCacheShape>;

store: DataStore<TCacheShape>;

readonly typeDefs: any;

version: string;

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

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

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

getResolvers: () => Resolvers;

initQueryManager: () => QueryManager<TCacheShape>;

mutate: <T = any, TVariables = OperationVariables>(
    options: MutationOptions<T, TVariables>
) => Promise<FetchResult<T>>;

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

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

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

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

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

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

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

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

setLocalStateFragmentMatcher: (fragmentMatcher: FragmentMatcher) => void;

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

stop: () => void;

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

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

writeData: <TData = any>(options: DataProxy.WriteDataOptions<TData>) => void;

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

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

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

extraInfo: any;

graphQLErrors: readonly GraphQLError[];

message: string;

networkError: Error;

constructor({
    queryManager,
    options,
    shouldSubscribe,
}: {
    queryManager: QueryManager<any>;
    options: WatchQueryOptions<TVariables>;
    shouldSubscribe?: boolean;
});

options: WatchQueryOptions<TVariables>;

readonly queryId: string;

readonly queryName?: string;

variables: {};

currentResult: () => ApolloCurrentResult<TData>;

fetchMore: <K extends keyof TVariables>(
    fetchMoreOptions: FetchMoreQueryOptions<TVariables, K> &
        FetchMoreOptions<TData, TVariables>
) => Promise<ApolloQueryResult<TData>>;

getCurrentResult: () => ApolloCurrentQueryResult<TData>;

getLastError: () => ApolloError;

getLastResult: () => ApolloQueryResult<TData>;

isDifferentFromLastResult: (newResult: ApolloQueryResult<TData>) => boolean;

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

resetLastResults: () => void;

resetQueryStoreErrors: () => void;

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

setOptions: (
    opts: WatchQueryOptions
) => Promise<ApolloQueryResult<TData> | void>;

setVariables: (
    variables: TVariables,
    tryFetch?: boolean,
    fetchResults?: boolean
) => Promise<ApolloQueryResult<TData> | void>;

startPolling: (pollInterval: number) => void;

stopPolling: () => void;

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

updateQuery: <TVars = TVariables>(
    mapFn: (
        previousQueryResult: TData,
        options: UpdateQueryOptions<TVars>
    ) => TData
) => void;

mutate?: Partial<MutationOptions>;

query?: Partial<QueryOptions>;

watchQuery?: Partial<WatchQueryOptions>;

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

context?: any;

query?: DocumentNode;

variables?: Pick<TVariables, K>;

context?: any;

fetchPolicy?: FetchPolicy;

mutation: DocumentNode;

context?: any;

errorPolicy?: ErrorPolicy;

fetchResults?: boolean;

metadata?: any;

query: DocumentNode;

variables?: TVariables;

fetchPolicy?: FetchPolicy;

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

fetchPolicy?: FetchPolicy;

query: DocumentNode;

variables?: TVariables;

variables?: TVariables;

fetchPolicy?: WatchQueryFetchPolicy;

normal = 1

poll = 3

refetch = 2

error = 8

fetchMore = 3

loading = 1

poll = 6

ready = 7

refetch = 4

setVariables = 2