api-report-core.md

API Report File for "@apollo/client"

Do not edit this file. It is a report generated by API Extractor.

import type { ASTNode } from 'graphql';
import { disableExperimentalFragmentVariables } from 'graphql-tag';
import { disableFragmentWarnings } from 'graphql-tag';
import type { DocumentNode } from 'graphql';
import { enableExperimentalFragmentVariables } from 'graphql-tag';
import type { ExecutionResult } from 'graphql';
import type { FieldNode } from 'graphql';
import type { FragmentDefinitionNode } from 'graphql';
import { gql } from 'graphql-tag';
import type { GraphQLError } from 'graphql';
import type { GraphQLErrorExtensions } from 'graphql';
import type { InlineFragmentNode } from 'graphql';
import { InvariantError } from 'ts-invariant';
import { Observable } from 'zen-observable-ts';
import type { Subscription as ObservableSubscription } from 'zen-observable-ts';
import type { Observer } from 'zen-observable-ts';
import { resetCaches } from 'graphql-tag';
import type { SelectionSetNode } from 'graphql';
import { setVerbosity as setLogVerbosity } from 'ts-invariant';
import type { Subscriber } from 'zen-observable-ts';
import { Trie } from '@wry/trie';
import { TypedDocumentNode } from '@graphql-typed-document-node/core';

// Warning: (ae-forgotten-export) The symbol "Modifier" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "StoreObjectValueMaybeReference" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;

// @public (undocumented)
export abstract class ApolloCache<TSerialized> implements DataProxy {
    // (undocumented)
    readonly assumeImmutableResults: boolean;
    // (undocumented)
    batch<U>(options: Cache_2.BatchOptions<this, U>): U;
    // (undocumented)
    abstract diff<T>(query: Cache_2.DiffOptions): Cache_2.DiffResult<T>;
    // (undocumented)
    abstract evict(options: Cache_2.EvictOptions): boolean;
    // (undocumented)
    abstract extract(optimistic?: boolean): TSerialized;
    // (undocumented)
    gc(): string[];
    // (undocumented)
    identify(object: StoreObject | Reference): string | undefined;
    // (undocumented)
    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
    // (undocumented)
    abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
    // (undocumented)
    abstract read<TData = any, TVariables = any>(query: Cache_2.ReadOptions<TVariables, TData>): TData | null;
    // (undocumented)
    readFragment<FragmentType, TVariables = any>(options: Cache_2.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
    // (undocumented)
    readQuery<QueryType, TVariables = any>(options: Cache_2.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
    // (undocumented)
    recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
    // (undocumented)
    abstract removeOptimistic(id: string): void;
    // (undocumented)
    abstract reset(options?: Cache_2.ResetOptions): Promise<void>;
    // (undocumented)
    abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
    // (undocumented)
    transformDocument(document: DocumentNode): DocumentNode;
    // (undocumented)
    transformForLink(document: DocumentNode): DocumentNode;
    // (undocumented)
    updateFragment<TData = any, TVariables = any>(options: Cache_2.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
    // (undocumented)
    updateQuery<TData = any, TVariables = any>(options: Cache_2.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
    // (undocumented)
    abstract watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
    // (undocumented)
    abstract write<TData = any, TVariables = any>(write: Cache_2.WriteOptions<TData, TVariables>): Reference | undefined;
    // (undocumented)
    writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache_2.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
    // (undocumented)
    writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache_2.WriteQueryOptions<TData, TVariables>): Reference | undefined;
}

// @public (undocumented)
export class ApolloClient<TCacheShape> implements DataProxy {
    // (undocumented)
    __actionHookForDevTools(cb: () => any): void;
    constructor(options: ApolloClientOptions<TCacheShape>);
    // (undocumented)
    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult>;
    // (undocumented)
    addResolvers(resolvers: Resolvers | Resolvers[]): void;
    // (undocumented)
    cache: ApolloCache<TCacheShape>;
    // (undocumented)
    clearStore(): Promise<any[]>;
    // (undocumented)
    get defaultContext(): Partial<DefaultContext>;
    // (undocumented)
    defaultOptions: DefaultOptions;
    // (undocumented)
    disableNetworkFetches: boolean;
    // (undocumented)
    get documentTransform(): DocumentTransform;
    // (undocumented)
    extract(optimistic?: boolean): TCacheShape;
    // (undocumented)
    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
    // (undocumented)
    getResolvers(): Resolvers;
    // (undocumented)
    link: ApolloLink;
    // (undocumented)
    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>>;
    // (undocumented)
    onClearStore(cb: () => Promise<any>): () => void;
    // (undocumented)
    onResetStore(cb: () => Promise<any>): () => void;
    // (undocumented)
    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<T>>;
    // (undocumented)
    queryDeduplication: boolean;
    // (undocumented)
    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): T | null;
    // (undocumented)
    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): T | null;
    // (undocumented)
    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
    // (undocumented)
    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
    // (undocumented)
    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
    // (undocumented)
    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
    // (undocumented)
    setLink(newLink: ApolloLink): void;
    // (undocumented)
    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
    // (undocumented)
    setResolvers(resolvers: Resolvers | Resolvers[]): void;
    // (undocumented)
    stop(): void;
    // (undocumented)
    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<T>>;
    // (undocumented)
    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
    // (undocumented)
    version: string;
    // (undocumented)
    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
    // (undocumented)
    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
    // (undocumented)
    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
}

// @public (undocumented)
export 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;
    defaultContext?: Partial<DefaultContext>;
    assumeImmutableResults?: boolean;
    resolvers?: Resolvers | Resolvers[];
    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
    fragmentMatcher?: FragmentMatcher;
    name?: string;
    version?: string;
    documentTransform?: DocumentTransform;
};

// @public (undocumented)
export class ApolloError extends Error {
    // Warning: (ae-forgotten-export) The symbol "ApolloErrorOptions" needs to be exported by the entry point index.d.ts
    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
    // (undocumented)
    clientErrors: ReadonlyArray<Error>;
    // (undocumented)
    extraInfo: any;
    // Warning: (ae-forgotten-export) The symbol "GraphQLErrors" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    graphQLErrors: GraphQLErrors;
    // (undocumented)
    message: string;
    // (undocumented)
    name: string;
    // (undocumented)
    networkError: Error | ServerParseError | ServerError | null;
    // (undocumented)
    protocolErrors: ReadonlyArray<{
        message: string;
        extensions?: GraphQLErrorExtensions[];
    }>;
}

// @public (undocumented)
interface ApolloErrorOptions {
    // (undocumented)
    clientErrors?: ReadonlyArray<Error>;
    // (undocumented)
    errorMessage?: string;
    // (undocumented)
    extraInfo?: any;
    // (undocumented)
    graphQLErrors?: ReadonlyArray<GraphQLError>;
    // (undocumented)
    networkError?: Error | ServerParseError | ServerError | null;
    // (undocumented)
    protocolErrors?: ReadonlyArray<{
        message: string;
        extensions?: GraphQLErrorExtensions[];
    }>;
}

// @public (undocumented)
export class ApolloLink {
    constructor(request?: RequestHandler);
    // (undocumented)
    static concat(first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler): ApolloLink;
    // (undocumented)
    concat(next: ApolloLink | RequestHandler): ApolloLink;
    // (undocumented)
    static empty(): ApolloLink;
    // (undocumented)
    static execute(link: ApolloLink, operation: GraphQLRequest): Observable<FetchResult>;
    // (undocumented)
    static from(links: (ApolloLink | RequestHandler)[]): ApolloLink;
    // (undocumented)
    protected onError(error: any, observer?: Observer<FetchResult>): false | void;
    // (undocumented)
    request(operation: Operation, forward?: NextLink): Observable<FetchResult> | null;
    // (undocumented)
    setOnError(fn: ApolloLink["onError"]): this;
    // (undocumented)
    static split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
    // (undocumented)
    split(test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler): ApolloLink;
}

// @public (undocumented)
export interface ApolloPayloadResult<TData = Record<string, any>, TExtensions = Record<string, any>> {
    // (undocumented)
    errors?: ReadonlyArray<Error | string>;
    // (undocumented)
    payload: SingleExecutionResult | ExecutionPatchResult | null;
}

// @public (undocumented)
export type ApolloQueryResult<T> = {
    data: T;
    errors?: ReadonlyArray<GraphQLError>;
    error?: ApolloError;
    loading: boolean;
    networkStatus: NetworkStatus;
    partial?: boolean;
};

// @public (undocumented)
export type ApolloReducerConfig = {
    dataIdFromObject?: KeyFieldsFunction;
    addTypename?: boolean;
};

// @public (undocumented)
type AsStoreObject<T extends {
    __typename?: string;
}> = {
    [K in keyof T]: T[K];
};

// @public (undocumented)
interface Body_2 {
    // (undocumented)
    extensions?: Record<string, any>;
    // (undocumented)
    operationName?: string;
    // (undocumented)
    query?: string;
    // (undocumented)
    variables?: Record<string, any>;
}

// @public (undocumented)
type BroadcastOptions = Pick<Cache_2.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;

// @public (undocumented)
namespace Cache_2 {
    // (undocumented)
    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
        // (undocumented)
        onWatchUpdated?: (this: TCache, watch: Cache_2.WatchOptions, diff: Cache_2.DiffResult<any>, lastDiff?: Cache_2.DiffResult<any> | undefined) => any;
        // (undocumented)
        optimistic?: string | boolean;
        // (undocumented)
        removeOptimistic?: string;
        // (undocumented)
        update(cache: TCache): TUpdateResult;
    }
    // (undocumented)
    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
    }
    // (undocumented)
    interface EvictOptions {
        // (undocumented)
        args?: Record<string, any>;
        // (undocumented)
        broadcast?: boolean;
        // (undocumented)
        fieldName?: string;
        // (undocumented)
        id?: string;
    }
    // (undocumented)
    interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
        // (undocumented)
        broadcast?: boolean;
        // Warning: (ae-forgotten-export) The symbol "Modifiers" needs to be exported by the entry point index.d.ts
        // Warning: (ae-forgotten-export) The symbol "AllFieldsModifier" needs to be exported by the entry point index.d.ts
        //
        // (undocumented)
        fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
        // (undocumented)
        id?: string;
        // (undocumented)
        optimistic?: boolean;
    }
    // (undocumented)
    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
        // (undocumented)
        canonizeResults?: boolean;
        // (undocumented)
        optimistic: boolean;
        // (undocumented)
        previousResult?: any;
        // (undocumented)
        returnPartialData?: boolean;
        // (undocumented)
        rootId?: string;
    }
    // (undocumented)
    interface ResetOptions {
        // (undocumented)
        discardWatches?: boolean;
    }
    // (undocumented)
    type WatchCallback<TData = any> = (diff: Cache_2.DiffResult<TData>, lastDiff?: Cache_2.DiffResult<TData>) => void;
    // (undocumented)
    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
        // (undocumented)
        callback: WatchCallback<TData>;
        // (undocumented)
        immediate?: boolean;
        // (undocumented)
        lastDiff?: DiffResult<TData>;
        // (undocumented)
        watcher?: object;
    }
    // (undocumented)
    interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
        // (undocumented)
        dataId?: string;
        // (undocumented)
        result: TResult;
    }
    import DiffResult = DataProxy.DiffResult;
    import ReadQueryOptions = DataProxy.ReadQueryOptions;
    import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
    import WriteQueryOptions = DataProxy.WriteQueryOptions;
    import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
    import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
    import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
    import Fragment = DataProxy.Fragment;
}
export { Cache_2 as Cache }

// @public (undocumented)
class CacheGroup {
    constructor(caching: boolean, parent?: CacheGroup | null);
    // (undocumented)
    readonly caching: boolean;
    // (undocumented)
    depend(dataId: string, storeFieldName: string): void;
    // (undocumented)
    dirty(dataId: string, storeFieldName: string): void;
    // (undocumented)
    keyMaker: Trie<object>;
    // (undocumented)
    resetCaching(): void;
}

// @public (undocumented)
const enum CacheWriteBehavior {
    // (undocumented)
    FORBID = 0,
    // (undocumented)
    MERGE = 2,
    // (undocumented)
    OVERWRITE = 1
}

// @public (undocumented)
type CanReadFunction = (value: StoreValue) => boolean;

// @public (undocumented)
export const checkFetcher: (fetcher: WindowOrWorkerGlobalScope["fetch"] | undefined) => void;

// @public (undocumented)
export type ClientParseError = InvariantError & {
    parseError: Error;
};

// @public (undocumented)
class Concast<T> extends Observable<T> {
    // Warning: (ae-forgotten-export) The symbol "MaybeAsync" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "ConcastSourcesIterable" needs to be exported by the entry point index.d.ts
    constructor(sources: MaybeAsync<ConcastSourcesIterable<T>> | Subscriber<T>);
    // (undocumented)
    addObserver(observer: Observer<T>): void;
    // Warning: (ae-forgotten-export) The symbol "NextResultListener" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    beforeNext(callback: NextResultListener): void;
    // (undocumented)
    cancel: (reason: any) => void;
    // (undocumented)
    readonly promise: Promise<T | undefined>;
    // (undocumented)
    removeObserver(observer: Observer<T>): void;
}

// Warning: (ae-forgotten-export) The symbol "Source" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type ConcastSourcesIterable<T> = Iterable<Source<T>>;

// @public (undocumented)
export const concat: typeof ApolloLink.concat;

// @public (undocumented)
export const createHttpLink: (linkOptions?: HttpOptions) => ApolloLink;

// @public (undocumented)
export const createSignalIfSupported: () => {
    controller: boolean;
    signal: boolean;
} | {
    controller: AbortController;
    signal: AbortSignal;
};

// @public (undocumented)
export namespace DataProxy {
    // (undocumented)
    export type DiffResult<T> = {
        result?: T;
        complete?: boolean;
        missing?: MissingFieldError[];
        fromOptimisticTransaction?: boolean;
    };
    // (undocumented)
    export interface Fragment<TVariables, TData> {
        // (undocumented)
        fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
        // (undocumented)
        fragmentName?: string;
        // (undocumented)
        id?: string;
        // (undocumented)
        variables?: TVariables;
    }
    // (undocumented)
    export interface Query<TVariables, TData> {
        // (undocumented)
        id?: string;
        // (undocumented)
        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
        // (undocumented)
        variables?: TVariables;
    }
    // (undocumented)
    export interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
        // (undocumented)
        canonizeResults?: boolean;
        // (undocumented)
        optimistic?: boolean;
        // (undocumented)
        returnPartialData?: boolean;
    }
    // (undocumented)
    export interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
        // (undocumented)
        canonizeResults?: boolean;
        // (undocumented)
        optimistic?: boolean;
        // (undocumented)
        returnPartialData?: boolean;
    }
    // (undocumented)
    export interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
    }
    // (undocumented)
    export interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
    }
    // (undocumented)
    export interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
    }
    // (undocumented)
    export interface WriteOptions<TData> {
        // (undocumented)
        broadcast?: boolean;
        // (undocumented)
        data: TData;
        // (undocumented)
        overwrite?: boolean;
    }
    // (undocumented)
    export interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
    }
}

// @public (undocumented)
export interface DataProxy {
    // (undocumented)
    readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
    // (undocumented)
    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
    // (undocumented)
    writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
    // (undocumented)
    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
}

// @public (undocumented)
export interface DefaultContext extends Record<string, any> {
}

// Warning: (ae-forgotten-export) The symbol "KeyFieldsContext" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export function defaultDataIdFromObject({ __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext): string | undefined;

// @public (undocumented)
export interface DefaultOptions {
    // (undocumented)
    mutate?: Partial<MutationOptions<any, any, any>>;
    // (undocumented)
    query?: Partial<QueryOptions<any, any>>;
    // (undocumented)
    watchQuery?: Partial<WatchQueryOptions<any, any>>;
}

// Warning: (ae-forgotten-export) The symbol "Printer" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export const defaultPrinter: Printer;

// @public (undocumented)
interface DeleteModifier {
    // (undocumented)
    [_deleteModifier]: true;
}

// @public (undocumented)
const _deleteModifier: unique symbol;

// @public (undocumented)
export type DiffQueryAgainstStoreOptions = ReadQueryOptions & {
    returnPartialData?: boolean;
};

export { disableExperimentalFragmentVariables }

export { disableFragmentWarnings }

export { DocumentNode }

// @public (undocumented)
export class DocumentTransform {
    // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
    constructor(transform: TransformFn, options?: DocumentTransformOptions);
    // (undocumented)
    concat(otherTransform: DocumentTransform): DocumentTransform;
    // (undocumented)
    getStableCacheEntry(document: DocumentNode): {
        key: DocumentTransformCacheKey;
        value?: DocumentNode | undefined;
    } | undefined;
    // (undocumented)
    static identity(): DocumentTransform;
    // (undocumented)
    resetCache(): void;
    // (undocumented)
    static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform;
    // (undocumented)
    transformDocument(document: DocumentNode): DocumentNode;
}

// @public (undocumented)
export type DocumentTransformCacheKey = ReadonlyArray<unknown>;

// @public (undocumented)
interface DocumentTransformOptions {
    // (undocumented)
    cache?: boolean;
    // (undocumented)
    getCacheKey?: (document: DocumentNode) => DocumentTransformCacheKey | undefined;
}

// @public (undocumented)
export const empty: typeof ApolloLink.empty;

export { enableExperimentalFragmentVariables }

// @public (undocumented)
abstract class EntityStore implements NormalizedCache {
    constructor(policies: Policies, group: CacheGroup);
    // Warning: (ae-forgotten-export) The symbol "Layer" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    abstract addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
    // Warning: (ae-forgotten-export) The symbol "CanReadFunction" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    canRead: CanReadFunction;
    // (undocumented)
    clear(): void;
    // (undocumented)
    protected data: NormalizedCacheObject;
    // (undocumented)
    delete(dataId: string, fieldName?: string, args?: Record<string, any>): boolean;
    // (undocumented)
    evict(options: Cache_2.EvictOptions, limit: EntityStore): boolean;
    // (undocumented)
    extract(): NormalizedCacheObject;
    // (undocumented)
    findChildRefIds(dataId: string): Record<string, true>;
    // (undocumented)
    gc(): string[];
    // (undocumented)
    get(dataId: string, fieldName: string): StoreValue;
    // Warning: (ae-forgotten-export) The symbol "SafeReadonly" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
    // (undocumented)
    getRootIdSet(ids?: Set<string>): Set<string>;
    // Warning: (ae-forgotten-export) The symbol "StorageType" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
    // Warning: (ae-forgotten-export) The symbol "CacheGroup" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    readonly group: CacheGroup;
    // (undocumented)
    has(dataId: string): boolean;
    // (undocumented)
    protected lookup(dataId: string, dependOnExistence?: boolean): StoreObject | undefined;
    // (undocumented)
    makeCacheKey(...args: any[]): object;
    // (undocumented)
    merge(older: string | StoreObject, newer: StoreObject | string): void;
    // (undocumented)
    modify(dataId: string, fields: Modifier<any> | Modifiers<Record<string, any>>): boolean;
    // Warning: (ae-forgotten-export) The symbol "Policies" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    readonly policies: Policies;
    // (undocumented)
    release(rootId: string): number;
    // (undocumented)
    abstract removeLayer(layerId: string): EntityStore;
    // (undocumented)
    replace(newData: NormalizedCacheObject | null): void;
    // (undocumented)
    retain(rootId: string): number;
    // (undocumented)
    toObject(): NormalizedCacheObject;
    // Warning: (ae-forgotten-export) The symbol "ToReferenceFunction" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    toReference: ToReferenceFunction;
}

// @public (undocumented)
namespace EntityStore {
    // (undocumented)
    class Root extends EntityStore {
        constructor({ policies, resultCaching, seed, }: {
            policies: Policies;
            resultCaching?: boolean;
            seed?: NormalizedCacheObject;
        });
        // (undocumented)
        addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
        // (undocumented)
        getStorage(): StorageType;
        // (undocumented)
        removeLayer(): Root;
        // (undocumented)
        readonly storageTrie: Trie<StorageType>;
        // Warning: (ae-forgotten-export) The symbol "Stump" needs to be exported by the entry point index.d.ts
        //
        // (undocumented)
        readonly stump: Stump;
    }
}

// @public (undocumented)
export type ErrorPolicy = "none" | "ignore" | "all";

// @public (undocumented)
export const execute: typeof ApolloLink.execute;

// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
    // (undocumented)
    data?: never;
    // (undocumented)
    errors?: never;
    // (undocumented)
    extensions?: never;
    // (undocumented)
    incremental?: IncrementalPayload<TData, TExtensions>[];
}

// @public (undocumented)
export interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
    // (undocumented)
    data: TData | null | undefined;
    // (undocumented)
    errors?: ReadonlyArray<GraphQLError>;
    // (undocumented)
    extensions?: TExtensions;
    // (undocumented)
    incremental?: never;
}

// @public (undocumented)
export type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;

// @public (undocumented)
interface ExecutionPatchResultBase {
    // (undocumented)
    hasNext?: boolean;
}

// @public (undocumented)
export const fallbackHttpConfig: {
    http: HttpQueryOptions;
    headers: {
        accept: string;
        "content-type": string;
    };
    options: {
        method: string;
    };
};

// @public (undocumented)
export interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {
    // (undocumented)
    updateQuery?: (previousQueryResult: TData, options: {
        fetchMoreResult?: TData;
        variables?: TVariables;
    }) => TData;
}

// @public (undocumented)
export interface FetchMoreQueryOptions<TVariables, TData = any> {
    // (undocumented)
    context?: DefaultContext;
    // (undocumented)
    query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
    // (undocumented)
    variables?: Partial<TVariables>;
}

// @public (undocumented)
export type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby";

// @public (undocumented)
export type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;

// @public (undocumented)
export interface FieldFunctionOptions<TArgs = Record<string, any>, TVars = Record<string, any>> {
    // (undocumented)
    args: TArgs | null;
    // (undocumented)
    cache: InMemoryCache;
    // (undocumented)
    canRead: CanReadFunction;
    // (undocumented)
    field: FieldNode | null;
    // (undocumented)
    fieldName: string;
    // (undocumented)
    isReference: typeof isReference;
    // Warning: (ae-forgotten-export) The symbol "MergeObjectsFunction" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    mergeObjects: MergeObjectsFunction;
    // Warning: (ae-forgotten-export) The symbol "ReadFieldFunction" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    readField: ReadFieldFunction;
    // (undocumented)
    storage: StorageType;
    // (undocumented)
    storeFieldName: string;
    // (undocumented)
    toReference: ToReferenceFunction;
    // (undocumented)
    variables?: TVars;
}

// @public (undocumented)
export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;

// @public (undocumented)
export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
    keyArgs?: KeySpecifier | KeyArgsFunction | false;
    read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
    merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
};

// @public (undocumented)
export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;

// @public (undocumented)
interface FieldSpecifier {
    // (undocumented)
    args?: Record<string, any>;
    // (undocumented)
    field?: FieldNode;
    // (undocumented)
    fieldName: string;
    // (undocumented)
    typename?: string;
    // (undocumented)
    variables?: Record<string, any>;
}

// Warning: (ae-forgotten-export) The symbol "EntityStore" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type FieldValueGetter = EntityStore["getFieldValue"];

// Warning: (ae-forgotten-export) The symbol "WriteContext" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type FlavorableWriteContext = Pick<WriteContext, "clientOnly" | "deferred" | "flavors">;

// @public (undocumented)
interface FragmentMap {
    // (undocumented)
    [fragmentName: string]: FragmentDefinitionNode;
}

// @public (undocumented)
type FragmentMapFunction = (fragmentName: string) => FragmentDefinitionNode | null;

// @public (undocumented)
export type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;

// @public (undocumented)
interface FragmentRegistryAPI {
    // (undocumented)
    lookup(fragmentName: string): FragmentDefinitionNode | null;
    // (undocumented)
    register(...fragments: DocumentNode[]): this;
    // (undocumented)
    resetCaches(): void;
    // (undocumented)
    transform<D extends DocumentNode>(document: D): D;
}

// @public (undocumented)
export const from: typeof ApolloLink.from;

// @public (undocumented)
export function fromError<T>(errorValue: any): Observable<T>;

// @public (undocumented)
export function fromPromise<T>(promise: Promise<T>): Observable<T>;

export { gql }

// @public (undocumented)
type GraphQLErrors = ReadonlyArray<GraphQLError>;

// @public (undocumented)
export interface GraphQLRequest<TVariables = Record<string, any>> {
    // (undocumented)
    context?: DefaultContext;
    // (undocumented)
    extensions?: Record<string, any>;
    // (undocumented)
    operationName?: string;
    // (undocumented)
    query: DocumentNode;
    // (undocumented)
    variables?: TVariables;
}

// @public (undocumented)
interface HttpConfig {
    // (undocumented)
    credentials?: any;
    // (undocumented)
    headers?: Record<string, string>;
    // (undocumented)
    http?: HttpQueryOptions;
    // (undocumented)
    options?: any;
}

// @public (undocumented)
export class HttpLink extends ApolloLink {
    constructor(options?: HttpOptions);
    // (undocumented)
    options: HttpOptions;
}

// @public (undocumented)
export interface HttpOptions {
    // (undocumented)
    credentials?: string;
    // (undocumented)
    fetch?: WindowOrWorkerGlobalScope["fetch"];
    // (undocumented)
    fetchOptions?: any;
    // (undocumented)
    headers?: Record<string, string>;
    // (undocumented)
    includeExtensions?: boolean;
    // (undocumented)
    includeUnusedVariables?: boolean;
    // (undocumented)
    preserveHeaderCase?: boolean;
    // (undocumented)
    print?: Printer;
    // (undocumented)
    uri?: string | UriFunction;
    // (undocumented)
    useGETForQueries?: boolean;
}

// @public (undocumented)
interface HttpQueryOptions {
    // (undocumented)
    includeExtensions?: boolean;
    // (undocumented)
    includeQuery?: boolean;
    // (undocumented)
    preserveHeaderCase?: boolean;
}

// @public (undocumented)
export type IdGetter = (value: IdGetterObj) => string | undefined;

// @public (undocumented)
export interface IdGetterObj extends Object {
    // (undocumented)
    __typename?: string;
    // (undocumented)
    id?: string;
    // (undocumented)
    _id?: string;
}

// @public (undocumented)
export interface IncrementalPayload<TData, TExtensions> {
    // (undocumented)
    data: TData | null;
    // (undocumented)
    errors?: ReadonlyArray<GraphQLError>;
    // (undocumented)
    extensions?: TExtensions;
    // (undocumented)
    label?: string;
    // (undocumented)
    path: Path;
}

// @public (undocumented)
export class InMemoryCache extends ApolloCache<NormalizedCacheObject> {
    constructor(config?: InMemoryCacheConfig);
    // (undocumented)
    readonly assumeImmutableResults = true;
    // (undocumented)
    batch<TUpdateResult>(options: Cache_2.BatchOptions<InMemoryCache, TUpdateResult>): TUpdateResult;
    // Warning: (ae-forgotten-export) The symbol "BroadcastOptions" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    protected broadcastWatches(options?: BroadcastOptions): void;
    // (undocumented)
    protected config: InMemoryCacheConfig;
    // (undocumented)
    diff<TData, TVariables extends OperationVariables = any>(options: Cache_2.DiffOptions<TData, TVariables>): Cache_2.DiffResult<TData>;
    // (undocumented)
    evict(options: Cache_2.EvictOptions): boolean;
    // (undocumented)
    extract(optimistic?: boolean): NormalizedCacheObject;
    // (undocumented)
    gc(options?: {
        resetResultCache?: boolean;
        resetResultIdentities?: boolean;
    }): string[];
    // (undocumented)
    identify(object: StoreObject | Reference): string | undefined;
    // (undocumented)
    readonly makeVar: typeof makeVar;
    // (undocumented)
    modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache_2.ModifyOptions<Entity>): boolean;
    // (undocumented)
    performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any;
    // (undocumented)
    readonly policies: Policies;
    // (undocumented)
    read<T>(options: Cache_2.ReadOptions): T | null;
    // (undocumented)
    release(rootId: string, optimistic?: boolean): number;
    // (undocumented)
    removeOptimistic(idToRemove: string): void;
    // (undocumented)
    reset(options?: Cache_2.ResetOptions): Promise<void>;
    // (undocumented)
    restore(data: NormalizedCacheObject): this;
    // (undocumented)
    retain(rootId: string, optimistic?: boolean): number;
    // (undocumented)
    transformDocument(document: DocumentNode): DocumentNode;
    // (undocumented)
    watch<TData = any, TVariables = any>(watch: Cache_2.WatchOptions<TData, TVariables>): () => void;
    // (undocumented)
    write(options: Cache_2.WriteOptions): Reference | undefined;
}

// @public (undocumented)
export interface InMemoryCacheConfig extends ApolloReducerConfig {
    // (undocumented)
    canonizeResults?: boolean;
    // Warning: (ae-forgotten-export) The symbol "FragmentRegistryAPI" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    fragments?: FragmentRegistryAPI;
    // (undocumented)
    possibleTypes?: PossibleTypesMap;
    // (undocumented)
    resultCacheMaxSize?: number;
    // (undocumented)
    resultCaching?: boolean;
    // (undocumented)
    typePolicies?: TypePolicies;
}

// Warning: (ae-forgotten-export) The symbol "RefetchQueriesIncludeShorthand" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;

// @public (undocumented)
export type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;

// @public (undocumented)
export interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
    // (undocumented)
    include?: InternalRefetchQueriesInclude;
    // (undocumented)
    removeOptimistic?: string;
}

// @public (undocumented)
export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;

// @public (undocumented)
export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;

// @public (undocumented)
interface InvalidateModifier {
    // (undocumented)
    [_invalidateModifier]: true;
}

// @public (undocumented)
const _invalidateModifier: unique symbol;

// @public (undocumented)
export function isApolloError(err: Error): err is ApolloError;

// @public (undocumented)
export function isNetworkRequestSettled(networkStatus?: NetworkStatus): boolean;

// @public (undocumented)
export function isReference(obj: any): obj is Reference;

// Warning: (ae-forgotten-export) The symbol "UnionToIntersection" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "UnionForAny" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type IsStrictlyAny<T> = UnionToIntersection<UnionForAny<T>> extends never ? true : false;

// @public (undocumented)
type KeyArgsFunction = (args: Record<string, any> | null, context: {
    typename: string;
    fieldName: string;
    field: FieldNode | null;
    variables?: Record<string, any>;
}) => KeySpecifier | false | ReturnType<IdGetter>;

// @public (undocumented)
type KeyFieldsContext = {
    typename: string | undefined;
    storeObject: StoreObject;
    readField: ReadFieldFunction;
    selectionSet?: SelectionSetNode;
    fragmentMap?: FragmentMap;
    keyObject?: Record<string, any>;
};

// @public (undocumented)
type KeyFieldsFunction = (object: Readonly<StoreObject>, context: KeyFieldsContext) => KeySpecifier | false | ReturnType<IdGetter>;

// @public (undocumented)
type KeySpecifier = ReadonlyArray<string | KeySpecifier>;

// @public (undocumented)
class Layer extends EntityStore {
    constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup);
    // (undocumented)
    addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
    // (undocumented)
    findChildRefIds(dataId: string): Record<string, true>;
    // (undocumented)
    getStorage(): StorageType;
    // (undocumented)
    readonly group: CacheGroup;
    // (undocumented)
    readonly id: string;
    // (undocumented)
    readonly parent: EntityStore;
    // (undocumented)
    removeLayer(layerId: string): EntityStore;
    // (undocumented)
    readonly replay: (layer: EntityStore) => any;
    // (undocumented)
    toObject(): NormalizedCacheObject;
}

// @public (undocumented)
class LocalState<TCacheShape> {
    // Warning: (ae-forgotten-export) The symbol "LocalStateOptions" needs to be exported by the entry point index.d.ts
    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
    // (undocumented)
    addExportedVariables<TVars extends OperationVariables>(document: DocumentNode, variables?: TVars, context?: {}): Promise<TVars>;
    // (undocumented)
    addResolvers(resolvers: Resolvers | Resolvers[]): void;
    // (undocumented)
    clientQuery(document: DocumentNode): DocumentNode | null;
    // (undocumented)
    getFragmentMatcher(): FragmentMatcher | undefined;
    // (undocumented)
    getResolvers(): Resolvers;
    // (undocumented)
    prepareContext(context?: Record<string, any>): {
        cache: ApolloCache<TCacheShape>;
        getCacheKey(obj: StoreObject): string | undefined;
    };
    // (undocumented)
    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
        document: DocumentNode | null;
        remoteResult: FetchResult<TData>;
        context?: Record<string, any>;
        variables?: Record<string, any>;
        onlyRunForcedResolvers?: boolean;
    }): Promise<FetchResult<TData>>;
    // (undocumented)
    serverQuery(document: DocumentNode): DocumentNode | null;
    // (undocumented)
    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
    // (undocumented)
    setResolvers(resolvers: Resolvers | Resolvers[]): void;
    // (undocumented)
    shouldForceResolvers(document: ASTNode): boolean;
}

// @public (undocumented)
type LocalStateOptions<TCacheShape> = {
    cache: ApolloCache<TCacheShape>;
    client?: ApolloClient<TCacheShape>;
    resolvers?: Resolvers | Resolvers[];
    fragmentMatcher?: FragmentMatcher;
};

// @public (undocumented)
export function makeReference(id: string): Reference;

// @public (undocumented)
export function makeVar<T>(value: T): ReactiveVar<T>;

// @public (undocumented)
type MaybeAsync<T> = T | PromiseLike<T>;

// @public (undocumented)
export interface MergeInfo {
    // (undocumented)
    field: FieldNode;
    // (undocumented)
    merge: FieldMergeFunction;
    // (undocumented)
    typename: string | undefined;
}

// @public (undocumented)
type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;

// Warning: (ae-forgotten-export) The symbol "OptionsUnion" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export function mergeOptions<TDefaultOptions extends Partial<OptionsUnion<any, any, any>>, TOptions extends TDefaultOptions>(defaults: TDefaultOptions | Partial<TDefaultOptions> | undefined, options: TOptions | Partial<TOptions>): TOptions & TDefaultOptions;

// @public (undocumented)
export interface MergeTree {
    // (undocumented)
    info?: MergeInfo;
    // (undocumented)
    map: Map<string | number, MergeTree>;
}

// @public (undocumented)
export type MethodKeys<T> = {
    [P in keyof T]: T[P] extends Function ? P : never;
}[keyof T];

// @public (undocumented)
export class MissingFieldError extends Error {
    constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
    // (undocumented)
    readonly message: string;
    // (undocumented)
    readonly missing: MissingTree;
    // Warning: (ae-forgotten-export) The symbol "MissingTree" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    readonly path: MissingTree | Array<string | number>;
    // (undocumented)
    readonly query: DocumentNode;
    // (undocumented)
    readonly variables?: Record<string, any> | undefined;
}

// @public (undocumented)
type MissingTree = string | {
    readonly [key: string]: MissingTree;
};

// Warning: (ae-forgotten-export) The symbol "ModifierDetails" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "DeleteModifier" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "InvalidateModifier" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;

// @public (undocumented)
type ModifierDetails = {
    DELETE: DeleteModifier;
    INVALIDATE: InvalidateModifier;
    fieldName: string;
    storeFieldName: string;
    readField: ReadFieldFunction;
    canRead: CanReadFunction;
    isReference: typeof isReference;
    toReference: ToReferenceFunction;
    storage: StorageType;
};

// @public (undocumented)
type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
    [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
}>;

// @public (undocumented)
interface MutationBaseOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> {
    // (undocumented)
    awaitRefetchQueries?: boolean;
    // (undocumented)
    context?: TContext;
    // (undocumented)
    errorPolicy?: ErrorPolicy;
    // (undocumented)
    onQueryUpdated?: OnQueryUpdated<any>;
    // (undocumented)
    optimisticResponse?: TData | ((vars: TVariables) => TData);
    // (undocumented)
    refetchQueries?: ((result: FetchResult<TData>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
    // (undocumented)
    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
    // (undocumented)
    updateQueries?: MutationQueryReducersMap<TData>;
    // (undocumented)
    variables?: TVariables;
}

// @public (undocumented)
export type MutationFetchPolicy = Extract<FetchPolicy, "network-only" | "no-cache">;

// Warning: (ae-forgotten-export) The symbol "MutationBaseOptions" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export interface MutationOptions<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
    // (undocumented)
    fetchPolicy?: MutationFetchPolicy;
    // (undocumented)
    keepRootFields?: boolean;
    // (undocumented)
    mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
}

// @public (undocumented)
export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
    mutationResult: FetchResult<T>;
    queryName: string | undefined;
    queryVariables: Record<string, any>;
}) => Record<string, any>;

// @public (undocumented)
export type MutationQueryReducersMap<T = {
    [key: string]: any;
}> = {
    [queryName: string]: MutationQueryReducer<T>;
};

// @public (undocumented)
interface MutationStoreValue {
    // (undocumented)
    error: Error | null;
    // (undocumented)
    loading: boolean;
    // (undocumented)
    mutation: DocumentNode;
    // (undocumented)
    variables: Record<string, any>;
}

// @public (undocumented)
export type MutationUpdaterFn<T = {
    [key: string]: any;
}> = (cache: ApolloCache<T>, mutationResult: FetchResult<T>) => void;

// @public (undocumented)
export type MutationUpdaterFunction<TData, TVariables, TContext, TCache extends ApolloCache<any>> = (cache: TCache, result: Omit<FetchResult<TData>, "context">, options: {
    context?: TContext;
    variables?: TVariables;
}) => void;

// @public (undocumented)
export enum NetworkStatus {
    // (undocumented)
    error = 8,
    // (undocumented)
    fetchMore = 3,
    // (undocumented)
    loading = 1,
    // (undocumented)
    poll = 6,
    // (undocumented)
    ready = 7,
    // (undocumented)
    refetch = 4,
    // (undocumented)
    setVariables = 2
}

// @public (undocumented)
interface NextFetchPolicyContext<TData, TVariables extends OperationVariables> {
    // (undocumented)
    initialFetchPolicy: WatchQueryFetchPolicy;
    // (undocumented)
    observable: ObservableQuery<TData, TVariables>;
    // (undocumented)
    options: WatchQueryOptions<TVariables, TData>;
    // (undocumented)
    reason: "after-fetch" | "variables-changed";
}

// @public (undocumented)
export type NextLink = (operation: Operation) => Observable<FetchResult>;

// @public (undocumented)
type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any;

// @public (undocumented)
export interface NormalizedCache {
    // (undocumented)
    canRead: CanReadFunction;
    // (undocumented)
    clear(): void;
    // (undocumented)
    delete(dataId: string, fieldName?: string): boolean;
    // (undocumented)
    get(dataId: string, fieldName: string): StoreValue;
    // Warning: (ae-forgotten-export) The symbol "FieldValueGetter" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    getFieldValue: FieldValueGetter;
    // (undocumented)
    getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
    // (undocumented)
    has(dataId: string): boolean;
    // (undocumented)
    merge(olderId: string, newerObject: StoreObject): void;
    // (undocumented)
    merge(olderObject: StoreObject, newerId: string): void;
    // (undocumented)
    modify<Entity extends Record<string, any>>(dataId: string, fields: Modifiers<Entity> | AllFieldsModifier<Entity>): boolean;
    // (undocumented)
    release(rootId: string): number;
    // (undocumented)
    replace(newData: NormalizedCacheObject): void;
    // (undocumented)
    retain(rootId: string): number;
    // (undocumented)
    toObject(): NormalizedCacheObject;
    // (undocumented)
    toReference: ToReferenceFunction;
}

// @public (undocumented)
export interface NormalizedCacheObject {
    // (undocumented)
    [dataId: string]: StoreObject | undefined;
    // (undocumented)
    __META?: {
        extraRootIds: string[];
    };
}

export { Observable }

// @public (undocumented)
export class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
    constructor({ queryManager, queryInfo, options, }: {
        queryManager: QueryManager<any>;
        queryInfo: QueryInfo;
        options: WatchQueryOptions<TVariables, TData>;
    });
    // (undocumented)
    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & {
        updateQuery?: (previousQueryResult: TData, options: {
            fetchMoreResult: TFetchData;
            variables: TFetchVars;
        }) => TData;
    }): Promise<ApolloQueryResult<TFetchData>>;
    // (undocumented)
    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<TData>;
    // (undocumented)
    getLastError(variablesMustMatch?: boolean): ApolloError | undefined;
    // (undocumented)
    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
    // (undocumented)
    hasObservers(): boolean;
    // (undocumented)
    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
    // (undocumented)
    readonly options: WatchQueryOptions<TVariables, TData>;
    // (undocumented)
    get query(): TypedDocumentNode<TData, TVariables>;
    // (undocumented)
    readonly queryId: string;
    // (undocumented)
    readonly queryName?: string;
    // (undocumented)
    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>>;
    // (undocumented)
    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
    // Warning: (ae-forgotten-export) The symbol "Concast" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    reobserveAsConcast(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
    // (undocumented)
    resetLastResults(): void;
    // (undocumented)
    resetQueryStoreErrors(): void;
    // (undocumented)
    resubscribeAfterError(onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void): ObservableSubscription;
    // (undocumented)
    resubscribeAfterError(observer: Observer<ApolloQueryResult<TData>>): ObservableSubscription;
    // (undocumented)
    result(): Promise<ApolloQueryResult<TData>>;
    // (undocumented)
    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<TData>>;
    // (undocumented)
    setVariables(variables: TVariables): Promise<ApolloQueryResult<TData> | void>;
    // (undocumented)
    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
    // (undocumented)
    startPolling(pollInterval: number): void;
    // (undocumented)
    stopPolling(): void;
    // (undocumented)
    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
    // (undocumented)
    updateQuery<TVars extends OperationVariables = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, "variables">) => TData): void;
    // (undocumented)
    get variables(): TVariables | undefined;
}

export { ObservableSubscription }

export { Observer }

// @public (undocumented)
export type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache_2.DiffResult<any>, lastDiff: Cache_2.DiffResult<any> | undefined) => boolean | TResult;

// @public (undocumented)
export interface Operation {
    // (undocumented)
    extensions: Record<string, any>;
    // (undocumented)
    getContext: () => DefaultContext;
    // (undocumented)
    operationName: string;
    // (undocumented)
    query: DocumentNode;
    // (undocumented)
    setContext: (context: DefaultContext) => DefaultContext;
    // (undocumented)
    variables: Record<string, any>;
}

// @public (undocumented)
export type OperationVariables = Record<string, any>;

// @public (undocumented)
export type OptimisticStoreItem = {
    id: string;
    data: NormalizedCacheObject;
    transaction: Transaction<NormalizedCacheObject>;
};

// @public (undocumented)
type OptionsUnion<TData, TVariables extends OperationVariables, TContext> = WatchQueryOptions<TVariables, TData> | QueryOptions<TVariables, TData> | MutationOptions<TData, TVariables, TContext, any>;

// @public (undocumented)
export function parseAndCheckHttpResponse(operations: Operation | Operation[]): (response: Response) => Promise<any>;

// @public (undocumented)
export type Path = ReadonlyArray<string | number>;

// @public (undocumented)
class Policies {
    constructor(config: {
        cache: InMemoryCache;
        dataIdFromObject?: KeyFieldsFunction;
        possibleTypes?: PossibleTypesMap;
        typePolicies?: TypePolicies;
    });
    // (undocumented)
    addPossibleTypes(possibleTypes: PossibleTypesMap): void;
    // (undocumented)
    addTypePolicies(typePolicies: TypePolicies): void;
    // (undocumented)
    readonly cache: InMemoryCache;
    // (undocumented)
    fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string | undefined, result?: Record<string, any>, variables?: Record<string, any>): boolean;
    // (undocumented)
    getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
    // (undocumented)
    getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
    // Warning: (ae-forgotten-export) The symbol "FieldSpecifier" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    getStoreFieldName(fieldSpec: FieldSpecifier): string;
    // (undocumented)
    hasKeyArgs(typename: string | undefined, fieldName: string): boolean;
    // (undocumented)
    identify(object: StoreObject, partialContext?: Partial<KeyFieldsContext>): [string?, StoreObject?];
    // Warning: (ae-forgotten-export) The symbol "ReadFieldOptions" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
    // (undocumented)
    readonly rootIdsByTypename: Record<string, string>;
    // (undocumented)
    readonly rootTypenamesById: Record<string, string>;
    // (undocumented)
    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
    // (undocumented)
    readonly usingPossibleTypes = false;
}

// @public (undocumented)
export type PossibleTypesMap = {
    [supertype: string]: string[];
};

// @public (undocumented)
const print_2: ((ast: ASTNode) => string) & {
    reset(): void;
};

// @public (undocumented)
interface Printer {
    // Warning: (ae-forgotten-export) The symbol "print_2" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    (node: ASTNode, originalPrint: typeof print_2): string;
}

// @public (undocumented)
class QueryInfo {
    constructor(queryManager: QueryManager<any>, queryId?: string);
    // (undocumented)
    document: DocumentNode | null;
    // (undocumented)
    getDiff(): Cache_2.DiffResult<any>;
    // (undocumented)
    graphQLErrors?: ReadonlyArray<GraphQLError>;
    // (undocumented)
    init(query: {
        document: DocumentNode;
        variables: Record<string, any> | undefined;
        networkStatus?: NetworkStatus;
        observableQuery?: ObservableQuery<any, any>;
        lastRequestId?: number;
    }): this;
    // (undocumented)
    lastRequestId: number;
    // (undocumented)
    listeners: Set<QueryListener>;
    // (undocumented)
    markError(error: ApolloError): ApolloError;
    // (undocumented)
    markReady(): NetworkStatus;
    // Warning: (ae-forgotten-export) The symbol "CacheWriteBehavior" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): typeof result;
    // (undocumented)
    networkError?: Error | null;
    // (undocumented)
    networkStatus?: NetworkStatus;
    // (undocumented)
    notify(): void;
    // (undocumented)
    readonly observableQuery: ObservableQuery<any, any> | null;
    // (undocumented)
    readonly queryId: string;
    // (undocumented)
    reset(): void;
    // (undocumented)
    resetLastWrite(): void;
    // (undocumented)
    setDiff(diff: Cache_2.DiffResult<any> | null): void;
    // (undocumented)
    setObservableQuery(oq: ObservableQuery<any, any> | null): void;
    // (undocumented)
    stop(): void;
    // (undocumented)
    stopped: boolean;
    // (undocumented)
    variables?: Record<string, any>;
}

// @public (undocumented)
export type QueryListener = (queryInfo: QueryInfo) => void;

// @public (undocumented)
class QueryManager<TStore> {
    constructor({ cache, link, defaultOptions, documentTransform, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, defaultContext, }: {
        cache: ApolloCache<TStore>;
        link: ApolloLink;
        defaultOptions?: DefaultOptions;
        documentTransform?: DocumentTransform;
        queryDeduplication?: boolean;
        onBroadcast?: () => void;
        ssrMode?: boolean;
        clientAwareness?: Record<string, string>;
        localState?: LocalState<TStore>;
        assumeImmutableResults?: boolean;
        defaultContext?: Partial<DefaultContext>;
    });
    // (undocumented)
    readonly assumeImmutableResults: boolean;
    // (undocumented)
    broadcastQueries(): void;
    // (undocumented)
    cache: ApolloCache<TStore>;
    // (undocumented)
    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
    // (undocumented)
    readonly defaultContext: Partial<DefaultContext>;
    // (undocumented)
    defaultOptions: DefaultOptions;
    // (undocumented)
    readonly documentTransform: DocumentTransform;
    // (undocumented)
    protected fetchCancelFns: Map<string, (error: any) => any>;
    // (undocumented)
    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
    // (undocumented)
    generateMutationId(): string;
    // (undocumented)
    generateQueryId(): string;
    // (undocumented)
    generateRequestId(): number;
    // Warning: (ae-forgotten-export) The symbol "TransformCacheEntry" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    getDocumentInfo(document: DocumentNode): TransformCacheEntry;
    // (undocumented)
    getLocalState(): LocalState<TStore>;
    // (undocumented)
    getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
    // Warning: (ae-forgotten-export) The symbol "QueryStoreValue" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    getQueryStore(): Record<string, QueryStoreValue>;
    // (undocumented)
    protected inFlightLinkObservables: Map<string, Map<string, Observable<FetchResult>>>;
    // (undocumented)
    link: ApolloLink;
    // (undocumented)
    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
        mutationId: string;
        document: DocumentNode;
        variables?: TVariables;
        fetchPolicy?: MutationFetchPolicy;
        errorPolicy: ErrorPolicy;
        context?: TContext;
        updateQueries: UpdateQueries<TData>;
        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
        keepRootFields?: boolean;
    }): void;
    // (undocumented)
    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
        mutationId: string;
        result: FetchResult<TData>;
        document: DocumentNode;
        variables?: TVariables;
        fetchPolicy?: MutationFetchPolicy;
        errorPolicy: ErrorPolicy;
        context?: TContext;
        updateQueries: UpdateQueries<TData>;
        update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
        awaitRefetchQueries?: boolean;
        refetchQueries?: InternalRefetchQueriesInclude;
        removeOptimistic?: string;
        onQueryUpdated?: OnQueryUpdated<any>;
        keepRootFields?: boolean;
    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
    // (undocumented)
    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<TData>>;
    // (undocumented)
    mutationStore?: {
        [mutationId: string]: MutationStoreValue;
    };
    // (undocumented)
    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
    // (undocumented)
    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
    // (undocumented)
    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
    // (undocumented)
    removeQuery(queryId: string): void;
    // (undocumented)
    resetErrors(queryId: string): void;
    // (undocumented)
    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
    // (undocumented)
    readonly ssrMode: boolean;
    // (undocumented)
    startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
    // (undocumented)
    stop(): void;
    // (undocumented)
    stopQuery(queryId: string): void;
    // (undocumented)
    stopQueryInStore(queryId: string): void;
    // (undocumented)
    transform(document: DocumentNode): DocumentNode;
    // (undocumented)
    watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
}

// @public (undocumented)
interface QueryOptions<TVariables = OperationVariables, TData = any> {
    // (undocumented)
    canonizeResults?: boolean;
    // (undocumented)
    context?: DefaultContext;
    // (undocumented)
    errorPolicy?: ErrorPolicy;
    // (undocumented)
    fetchPolicy?: FetchPolicy;
    // (undocumented)
    notifyOnNetworkStatusChange?: boolean;
    // (undocumented)
    partialRefetch?: boolean;
    // (undocumented)
    pollInterval?: number;
    // (undocumented)
    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
    // (undocumented)
    returnPartialData?: boolean;
    // (undocumented)
    variables?: TVariables;
}
export { QueryOptions as PureQueryOptions }
export { QueryOptions }

// @public (undocumented)
type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;

// @public (undocumented)
type ReactiveListener<T> = (value: T) => any;

// @public (undocumented)
export interface ReactiveVar<T> {
    // (undocumented)
    (newValue?: T): T;
    // (undocumented)
    attachCache(cache: ApolloCache<any>): this;
    // (undocumented)
    forgetCache(cache: ApolloCache<any>): boolean;
    // Warning: (ae-forgotten-export) The symbol "ReactiveListener" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    onNextChange(listener: ReactiveListener<T>): () => void;
}

// @public (undocumented)
interface ReadFieldFunction {
    // (undocumented)
    <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
    // (undocumented)
    <V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
}

// @public (undocumented)
interface ReadFieldOptions extends FieldSpecifier {
    // (undocumented)
    from?: StoreObject | Reference;
}

// @public (undocumented)
export interface ReadMergeModifyContext {
    // (undocumented)
    store: NormalizedCache;
    // (undocumented)
    variables?: Record<string, any>;
    // (undocumented)
    varString?: string;
}

// @public (undocumented)
export type ReadQueryOptions = {
    store: NormalizedCache;
    query: DocumentNode;
    variables?: Object;
    previousResult?: any;
    canonizeResults?: boolean;
    rootId?: string;
    config?: ApolloReducerConfig;
};

// @public (undocumented)
export interface Reference {
    // (undocumented)
    readonly __ref: string;
}

// @public (undocumented)
export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;

// @public (undocumented)
type RefetchQueriesIncludeShorthand = "all" | "active";

// @public (undocumented)
export interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {
    // (undocumented)
    include?: RefetchQueriesInclude;
    // (undocumented)
    onQueryUpdated?: OnQueryUpdated<TResult> | null;
    // (undocumented)
    optimistic?: boolean;
    // (undocumented)
    updateCache?: (cache: TCache) => void;
}

// Warning: (ae-forgotten-export) The symbol "IsStrictlyAny" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];

// @public (undocumented)
export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
    // (undocumented)
    queries: ObservableQuery<any>[];
    // (undocumented)
    results: InternalRefetchQueriesResult<TResult>[];
}

// @public (undocumented)
export type RefetchQueryDescriptor = string | DocumentNode;

// @public (undocumented)
export type RefetchWritePolicy = "merge" | "overwrite";

// @public (undocumented)
export type RequestHandler = (operation: Operation, forward: NextLink) => Observable<FetchResult> | null;

export { resetCaches }

// @public (undocumented)
export type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
    field: FieldNode;
    fragmentMap: FragmentMap;
}) => any;

// @public (undocumented)
export interface Resolvers {
    // (undocumented)
    [key: string]: {
        [field: string]: Resolver;
    };
}

// Warning: (ae-forgotten-export) The symbol "Body_2" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export function rewriteURIForGET(chosenURI: string, body: Body_2): {
    parseError: unknown;
    newURI?: undefined;
} | {
    newURI: string;
    parseError?: undefined;
};

// @public (undocumented)
type SafeReadonly<T> = T extends object ? Readonly<T> : T;

// Warning: (ae-forgotten-export) The symbol "HttpConfig" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export function selectHttpOptionsAndBody(operation: Operation, fallbackConfig: HttpConfig, ...configs: Array<HttpConfig>): {
    options: HttpConfig & Record<string, any>;
    body: Body_2;
};

// @public (undocumented)
export function selectHttpOptionsAndBodyInternal(operation: Operation, printer: Printer, ...configs: HttpConfig[]): {
    options: HttpConfig & Record<string, any>;
    body: Body_2;
};

// @public (undocumented)
export const selectURI: (operation: Operation, fallbackURI?: string | ((operation: Operation) => string) | undefined) => any;

// @public (undocumented)
export const serializeFetchParameter: (p: any, label: string) => string;

// @public (undocumented)
export type ServerError = Error & {
    response: Response;
    result: Record<string, any> | string;
    statusCode: number;
};

// @public (undocumented)
export type ServerParseError = Error & {
    response: Response;
    statusCode: number;
    bodyText: string;
};

export { setLogVerbosity }

// @public (undocumented)
export interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {
    // (undocumented)
    context?: TContext;
    // (undocumented)
    data?: TData | null;
}

// @public (undocumented)
type Source<T> = MaybeAsync<Observable<T>>;

// @public (undocumented)
export const split: typeof ApolloLink.split;

// @public (undocumented)
type StorageType = Record<string, any>;

// @public (undocumented)
export interface StoreObject {
    // (undocumented)
    [storeFieldName: string]: StoreValue;
    // (undocumented)
    __typename?: string;
}

// Warning: (ae-forgotten-export) The symbol "AsStoreObject" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Array<Record<string, any>> ? StoreVal extends Array<infer Item> ? Item extends Record<string, any> ? ReadonlyArray<AsStoreObject<Item> | Reference> : never : never : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference : StoreVal;

// @public (undocumented)
export type StoreValue = number | string | string[] | Reference | Reference[] | null | undefined | void | Object;

// @public (undocumented)
class Stump extends Layer {
    constructor(root: EntityStore.Root);
    // (undocumented)
    merge(older: string | StoreObject, newer: string | StoreObject): void;
    // (undocumented)
    removeLayer(): this;
}

// @public (undocumented)
export type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
    document: DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
    variables?: TSubscriptionVariables;
    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
    onError?: (error: Error) => void;
    context?: DefaultContext;
};

// @public (undocumented)
export interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
    // (undocumented)
    context?: DefaultContext;
    // (undocumented)
    errorPolicy?: ErrorPolicy;
    // (undocumented)
    fetchPolicy?: FetchPolicy;
    // (undocumented)
    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
    // (undocumented)
    variables?: TVariables;
}

// @public (undocumented)
export const throwServerError: (response: Response, result: any, message: string) => never;

// @public (undocumented)
export function toPromise<R>(observable: Observable<R>): Promise<R>;

// @public (undocumented)
type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;

// @public (undocumented)
export type Transaction<T> = (c: ApolloCache<T>) => void;

// @public (undocumented)
interface TransformCacheEntry {
    // (undocumented)
    asQuery: DocumentNode;
    // (undocumented)
    clientQuery: DocumentNode | null;
    // (undocumented)
    defaultVars: OperationVariables;
    // (undocumented)
    hasClientExports: boolean;
    // (undocumented)
    hasForcedResolvers: boolean;
    // (undocumented)
    hasNonreactiveDirective: boolean;
    // (undocumented)
    serverQuery: DocumentNode | null;
}

// @public (undocumented)
type TransformFn = (document: DocumentNode) => DocumentNode;

export { TypedDocumentNode }

// @public (undocumented)
export type TypePolicies = {
    [__typename: string]: TypePolicy;
};

// @public (undocumented)
export type TypePolicy = {
    keyFields?: KeySpecifier | KeyFieldsFunction | false;
    merge?: FieldMergeFunction | boolean;
    queryType?: true;
    mutationType?: true;
    subscriptionType?: true;
    fields?: {
        [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
    };
};

// @public (undocumented)
type UnionForAny<T> = T extends never ? "a" : 1;

// @public (undocumented)
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

// @public (undocumented)
type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];

// @public (undocumented)
type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
    subscriptionData: {
        data: TSubscriptionData;
    };
    variables?: TSubscriptionVariables;
}) => TData;

// @public (undocumented)
export interface UpdateQueryOptions<TVariables> {
    // (undocumented)
    variables?: TVariables;
}

// @public (undocumented)
export interface UriFunction {
    // (undocumented)
    (operation: Operation): string;
}

// @public (undocumented)
export type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network";

// @public (undocumented)
export interface WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, "fetchPolicy"> {
    // (undocumented)
    fetchPolicy?: WatchQueryFetchPolicy;
    // (undocumented)
    initialFetchPolicy?: WatchQueryFetchPolicy;
    // Warning: (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
    // (undocumented)
    refetchWritePolicy?: RefetchWritePolicy;
}

// @public (undocumented)
interface WriteContext extends ReadMergeModifyContext {
    // (undocumented)
    clientOnly: boolean;
    // (undocumented)
    deferred: boolean;
    // Warning: (ae-forgotten-export) The symbol "FlavorableWriteContext" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    flavors: Map<string, FlavorableWriteContext>;
    // (undocumented)
    readonly fragmentMap: FragmentMap;
    // (undocumented)
    incomingById: Map<string, {
        storeObject: StoreObject;
        mergeTree?: MergeTree;
        fieldNodeSet: Set<FieldNode>;
    }>;
    // Warning: (ae-forgotten-export) The symbol "FragmentMapFunction" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    lookupFragment: FragmentMapFunction;
    // (undocumented)
    merge<T>(existing: T, incoming: T): T;
    // (undocumented)
    overwrite: boolean;
    // (undocumented)
    readonly written: {
        [dataId: string]: SelectionSetNode[];
    };
}

// Warnings were encountered during analysis:
//
// src/cache/inmemory/policies.ts:92:3 - (ae-forgotten-export) The symbol "FragmentMap" needs to be exported by the entry point index.d.ts
// src/cache/inmemory/policies.ts:161:3 - (ae-forgotten-export) The symbol "KeySpecifier" needs to be exported by the entry point index.d.ts
// src/cache/inmemory/policies.ts:161:3 - (ae-forgotten-export) The symbol "KeyArgsFunction" needs to be exported by the entry point index.d.ts
// src/cache/inmemory/types.ts:126:3 - (ae-forgotten-export) The symbol "KeyFieldsFunction" needs to be exported by the entry point index.d.ts
// src/core/ObservableQuery.ts:113:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
// src/core/ObservableQuery.ts:114:5 - (ae-forgotten-export) The symbol "QueryInfo" needs to be exported by the entry point index.d.ts
// src/core/QueryManager.ts:120:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts
// src/core/QueryManager.ts:154:5 - (ae-forgotten-export) The symbol "LocalState" needs to be exported by the entry point index.d.ts
// src/core/QueryManager.ts:385:7 - (ae-forgotten-export) The symbol "UpdateQueries" needs to be exported by the entry point index.d.ts
// src/core/watchQueryOptions.ts:191:3 - (ae-forgotten-export) The symbol "UpdateQueryFn" needs to be exported by the entry point index.d.ts
// src/link/http/selectHttpOptionsAndBody.ts:128:32 - (ae-forgotten-export) The symbol "HttpQueryOptions" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)