///
import { NetworkInterface } from '../transport/networkInterface';
import { ResultTransformer, ResultComparator, QueryListener, ApolloQueryResult, PureQueryOptions, FetchType, SubscriptionOptions } from './types';
import { ApolloStore, Store, ApolloReducerConfig } from '../store';
import { NormalizedCache } from '../data/storeUtils';
import { DocumentNode } from 'graphql';
import { MutationQueryReducersMap } from '../data/mutationResults';
import { QueryScheduler } from '../scheduler/scheduler';
import { ApolloStateSelector } from '../ApolloClient';
import { Observer, Observable } from '../util/Observable';
import { WatchQueryOptions } from './watchQueryOptions';
import { ObservableQuery } from './ObservableQuery';
export declare class QueryManager {
pollingTimers: {
[queryId: string]: any;
};
scheduler: QueryScheduler;
store: ApolloStore;
private addTypename;
private networkInterface;
private deduplicator;
private reduxRootSelector;
private resultTransformer;
private resultComparator;
private reducerConfig;
private queryDeduplication;
private queryListeners;
private queryDocuments;
private idCounter;
private fetchQueryPromises;
private observableQueries;
private queryIdsByName;
constructor({networkInterface, store, reduxRootSelector, reducerConfig, resultTransformer, resultComparator, addTypename, queryDeduplication}: {
networkInterface: NetworkInterface;
store: ApolloStore;
reduxRootSelector: ApolloStateSelector;
reducerConfig?: ApolloReducerConfig;
resultTransformer?: ResultTransformer;
resultComparator?: ResultComparator;
addTypename?: boolean;
queryDeduplication?: boolean;
});
broadcastNewStore(store: any): void;
mutate({mutation, variables, optimisticResponse, updateQueries: updateQueriesByName, refetchQueries}: {
mutation: DocumentNode;
variables?: Object;
optimisticResponse?: Object;
updateQueries?: MutationQueryReducersMap;
refetchQueries?: string[] | PureQueryOptions[];
}): Promise>;
queryListenerForObserver(queryId: string, options: WatchQueryOptions, observer: Observer>): QueryListener;
watchQuery(options: WatchQueryOptions, shouldSubscribe?: boolean): ObservableQuery;
query(options: WatchQueryOptions): Promise>;
fetchQuery(queryId: string, options: WatchQueryOptions, fetchType?: FetchType): Promise>;
generateQueryId(): string;
stopQueryInStore(queryId: string): void;
getApolloState(): Store;
selectApolloState(store: any): Store;
getInitialState(): {
data: Object;
};
getDataWithOptimisticResults(): NormalizedCache;
addQueryListener(queryId: string, listener: QueryListener): void;
addFetchQueryPromise(requestId: number, promise: Promise>, resolve: (result: ApolloQueryResult) => void, reject: (error: Error) => void): void;
removeFetchQueryPromise(requestId: number): void;
addObservableQuery(queryId: string, observableQuery: ObservableQuery): void;
removeObservableQuery(queryId: string): void;
resetStore(): void;
startQuery(queryId: string, options: WatchQueryOptions, listener: QueryListener): string;
startGraphQLSubscription(options: SubscriptionOptions): Observable;
stopQuery(queryId: string): void;
getCurrentQueryResult(observableQuery: ObservableQuery, isOptimistic?: boolean): any;
getQueryWithPreviousResult(queryIdOrObservable: string | ObservableQuery, isOptimistic?: boolean): {
previousResult: any;
variables: {
[key: string]: any;
} | undefined;
document: DocumentNode;
};
transformResult(result: ApolloQueryResult): ApolloQueryResult;
private getQueryParts(observableQuery);
private transformQueryDocument(options);
private getExtraReducers();
private fetchRequest({requestId, queryId, document, options});
private refetchQueryByName(queryName);
private broadcastQueries();
private generateRequestId();
}