Api Report Core.Api

import { ApolloCache } from '@apollo/client/cache';
import { ApolloLink } from '@apollo/client/link';
import { ApolloPayloadResult } from '@apollo/client/link';
import { ApolloReducerConfig } from '@apollo/client/cache';
import type { ApplyHKTImplementationWithDefault } from '@apollo/client/utilities/internal';
import { Cache as Cache_2 } from '@apollo/client/cache';
import { checkFetcher } from '@apollo/client/link/http';
import type { ClientAwarenessLink } from '@apollo/client/link/client-awareness';
import { CombinedGraphQLErrors } from '@apollo/client/errors';
import { CombinedProtocolErrors } from '@apollo/client/errors';
import { concat } from '@apollo/client/link';
import { createHttpLink } from '@apollo/client/link/http';
import { createSignalIfSupported } from '@apollo/client/link/http';
import type { DeepPartial } from '@apollo/client/utilities';
import { defaultDataIdFromObject } from '@apollo/client/cache';
import { defaultPrinter } from '@apollo/client/link/http';
import { DiffQueryAgainstStoreOptions } from '@apollo/client/cache';
import { disableExperimentalFragmentVariables } from 'graphql-tag';
import { disableFragmentWarnings } from 'graphql-tag';
import { DocumentNode } from '@apollo/client/link';
import type { DocumentNode as DocumentNode_2 } from 'graphql';
import { DocumentTransform } from '@apollo/client/utilities';
import { DocumentTransformCacheKey } from '@apollo/client/utilities';
import { empty } from '@apollo/client/link';
import { enableExperimentalFragmentVariables } from 'graphql-tag';
import { execute } from '@apollo/client/link';
import { extensionsSymbol } from '@apollo/client/utilities/internal';
import type { ExtensionsWithStreamInfo } from '@apollo/client/utilities/internal';
import { fallbackHttpConfig } from '@apollo/client/link/http';
import { FetchResult } from '@apollo/client/link';
import { FieldFunctionOptions } from '@apollo/client/cache';
import { FieldMergeFunction } from '@apollo/client/cache';
import { FieldPolicy } from '@apollo/client/cache';
import { FieldReadFunction } from '@apollo/client/cache';
import type { FormattedExecutionResult } from 'graphql';
import { FragmentType } from '@apollo/client/masking';
import { from } from '@apollo/client/link';
import { getApolloClientMemoryInternals } from '@apollo/client/utilities/internal';
import { gql } from 'graphql-tag';
import { GraphQLRequest } from '@apollo/client/link';
import type { HKT } from '@apollo/client/utilities';
import { HttpLink } from '@apollo/client/link/http';
import { IdGetter } from '@apollo/client/cache';
import { IdGetterObj } from '@apollo/client/cache';
import type { IgnoreModifier } from '@apollo/client/cache';
import type { Incremental } from '@apollo/client/incremental';
import { InMemoryCache } from '@apollo/client/cache';
import { InMemoryCacheConfig } from '@apollo/client/cache';
import type { InteropObservable } from 'rxjs';
import type { IsAny } from '@apollo/client/utilities/internal';
import { isNetworkRequestSettled } from '@apollo/client/utilities';
import { isReference } from '@apollo/client/utilities';
import { LinkError } from '@apollo/client/errors';
import type { LocalState } from '@apollo/client/local-state';
import { LocalStateError } from '@apollo/client/errors';
import { makeVar } from '@apollo/client/cache';
import { MaybeMasked } from '@apollo/client/masking';
import { MergeInfo } from '@apollo/client/cache';
import { MergeTree } from '@apollo/client/cache';
import { MissingFieldError } from '@apollo/client/cache';
import type { NextNotification } from 'rxjs';
import { NormalizedCache } from '@apollo/client/cache';
import { NormalizedCacheObject } from '@apollo/client/cache';
import { Observable } from '@apollo/client/utilities';
import { Observable as Observable_2 } from 'rxjs';
import type { ObservableNotification } from 'rxjs';
import type { Observer } from 'rxjs';
import { Operation } from '@apollo/client/link';
import { OperationTypeNode } from 'graphql';
import { OptimisticStoreItem } from '@apollo/client/cache';
import { parseAndCheckHttpResponse } from '@apollo/client/link/http';
import { PossibleTypesMap } from '@apollo/client/cache';
import { ReactiveVar } from '@apollo/client/cache';
import { ReadMergeModifyContext } from '@apollo/client/cache';
import { ReadQueryOptions } from '@apollo/client/cache';
import { Reference } from '@apollo/client/utilities';
import type { Reference as Reference_2 } from '@apollo/client/cache';
import { RequestHandler } from '@apollo/client/link';
import { resetCaches } from 'graphql-tag';
import { rewriteURIForGET } from '@apollo/client/link/http';
import { selectHttpOptionsAndBody } from '@apollo/client/link/http';
import { selectHttpOptionsAndBodyInternal } from '@apollo/client/link/http';
import { selectURI } from '@apollo/client/link/http';
import { ServerError } from '@apollo/client/errors';
import { ServerParseError } from '@apollo/client/errors';
import { setVerbosity as setLogVerbosity } from '@apollo/client/utilities/invariant';
import { split } from '@apollo/client/link';
import { StoreObject } from '@apollo/client/utilities';
import { StoreValue } from '@apollo/client/cache';
import type { Subscribable } from 'rxjs';
import type { Subscription } from 'rxjs';
import { Transaction } from '@apollo/client/cache';
import { Trie } from '@wry/trie';
import { TypedDocumentNode } from '@graphql-typed-document-node/core';
import { TypePolicies } from '@apollo/client/cache';
import { TypePolicy } from '@apollo/client/cache';
import { UnconventionalError } from '@apollo/client/errors';
import { Unmasked } from '@apollo/client/masking';
import type { VariablesOption } from '@apollo/client/utilities/internal';
import type { variablesUnknownSymbol } from '@apollo/client/utilities/internal';
import { WatchFragmentOptions } from '@apollo/client/cache';
import { WatchFragmentResult } from '@apollo/client/cache';

export { ApolloCache }

// @public (undocumented)
export namespace ApolloClient {
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface ReadQueryOptions<TData, TVariables extends OperationVariables> {
            id?: string;
            optimistic?: boolean;
            query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
            returnPartialData?: boolean;
        }
    }
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface ReadFragmentOptions<TData, TVariables extends OperationVariables> {
            fragment: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
            fragmentName?: string;
            optimistic?: boolean;
            returnPartialData?: boolean;
        }
    }
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface WriteQueryOptions<TData, TVariables extends OperationVariables> {
            broadcast?: boolean;
            data: Unmasked<TData>;
            extensions?: Record<string, unknown>;
            id?: string;
            overwrite?: boolean;
            query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
        }
    }
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface WriteFragmentOptions<TData, TVariables extends OperationVariables> {
            broadcast?: boolean;
            data: Unmasked<TData>;
            fragment: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
            fragmentName?: string;
            overwrite?: boolean;
        }
    }
    // (undocumented)
    export interface DefaultOptions {
        // (undocumented)
        mutate?: Partial<ApolloClient.MutateOptions<any, any, any>>;
        // (undocumented)
        query?: Partial<ApolloClient.QueryOptions<any, any>>;
        // (undocumented)
        watchQuery?: Partial<ApolloClient.WatchQueryOptions<any, any>>;
    }
    // (undocumented)
    export interface DevtoolsOptions {
        enabled?: boolean;
        name?: string;
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export interface ReadQueryOptions<TData, TVariables extends OperationVariables> extends Base.ReadQueryOptions<TData, TVariables> {
            variables?: TVariables;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export interface ReadFragmentOptions<TData, TVariables extends OperationVariables> extends Base.ReadFragmentOptions<TData, TVariables> {
            from?: ApolloCache.FromOptionValue<TData>;
            id?: string;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
            variables?: TVariables;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
            variables?: TVariables;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export interface WriteFragmentOptions<TData, TVariables extends OperationVariables> extends Base.WriteFragmentOptions<TData, TVariables> {
            from?: ApolloCache.FromOptionValue<TData>;
            id?: string;
            variables?: TVariables;
        }
    }
    // (undocumented)
    export interface Experiment {
        // (undocumented)
        (this: ApolloClient, options: ApolloClient.Options): void;
        // (undocumented)
        v: 1;
    }
    // (undocumented)
    export type MutateOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = {
        optimisticResponse?: Unmasked<NoInfer<TData>> | ((vars: TVariables, { IGNORE }: {
            IGNORE: IgnoreModifier;
        }) => Unmasked<NoInfer<TData>> | IgnoreModifier);
        updateQueries?: MutationQueryReducersMap<TData>;
        refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
        awaitRefetchQueries?: boolean;
        update?: MutationUpdaterFunction<TData, TVariables, TCache>;
        onQueryUpdated?: OnQueryUpdated<any>;
        errorPolicy?: ErrorPolicy;
        context?: DefaultContext;
        fetchPolicy?: MutationFetchPolicy;
        keepRootFields?: boolean;
        mutation: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
    } & VariablesOption<NoInfer<TVariables>>;
    // (undocumented)
    export interface MutateResult<TData = unknown> {
        data: TData | undefined;
        error?: ErrorLike;
        extensions?: Record<string, unknown>;
    }
    // (undocumented)
    export interface ObservableFragment<TData = unknown> extends Observable_2<ApolloClient.WatchFragmentResult<TData>> {
        getCurrentResult: () => ApolloClient.WatchFragmentResult<TData>;
    }
    // (undocumented)
    export interface Options {
        assumeImmutableResults?: boolean;
        cache: ApolloCache;
        // (undocumented)
        clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
        dataMasking?: boolean;
        // (undocumented)
        defaultContext?: Partial<DefaultContext>;
        defaultOptions?: ApolloClient.DefaultOptions;
        devtools?: ApolloClient.DevtoolsOptions;
        // (undocumented)
        documentTransform?: DocumentTransform;
        // (undocumented)
        enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
        experiments?: ApolloClient.Experiment[];
        incrementalHandler?: Incremental.Handler<any>;
        link: ApolloLink;
        // (undocumented)
        localState?: LocalState;
        queryDeduplication?: boolean;
        ssrForceFetchDelay?: number;
        ssrMode?: boolean;
    }
    export type QueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
        query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
        errorPolicy?: ErrorPolicy;
        context?: DefaultContext;
        fetchPolicy?: FetchPolicy;
    } & VariablesOption<NoInfer<TVariables>>;
    // (undocumented)
    export interface QueryResult<TData = unknown> {
        data: TData | undefined;
        error?: ErrorLike;
    }
    // (undocumented)
    export type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache_2.CacheIdentifierOption<TData>;
    // (undocumented)
    export type ReadQueryOptions<TData, TVariables extends OperationVariables> = Base.ReadQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
    export interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
        include?: RefetchQueriesInclude;
        onQueryUpdated?: OnQueryUpdated<TResult> | null;
        optimistic?: boolean;
        updateCache?: (cache: TCache) => void;
    }
    export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>>, RefetchQueriesResult.AdditionalProperties<TResult> {
    }
    // (undocumented)
    export namespace RefetchQueriesResult {
        // (undocumented)
        export interface AdditionalProperties<TResult> {
            queries: ObservableQuery<any>[];
            results: InternalRefetchQueriesResult<TResult>[];
        }
    }
    // (undocumented)
    export type SubscribeOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
        query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
        fetchPolicy?: FetchPolicy;
        errorPolicy?: ErrorPolicy;
        context?: DefaultContext;
        extensions?: Record<string, any>;
    } & VariablesOption<NoInfer<TVariables>>;
    // (undocumented)
    export interface SubscribeResult<TData = unknown> {
        data: TData | undefined;
        error?: ErrorLike;
        extensions?: Record<string, unknown>;
    }
    // (undocumented)
    export type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache.WatchFragmentOptions<TData, TVariables>;
    // (undocumented)
    export type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<MaybeMasked<TData>>;
    export type WatchQueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
        fetchPolicy?: WatchQueryFetchPolicy;
        nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
        initialFetchPolicy?: WatchQueryFetchPolicy;
        refetchWritePolicy?: RefetchWritePolicy;
        errorPolicy?: ErrorPolicy;
        context?: DefaultContext;
        pollInterval?: number;
        notifyOnNetworkStatusChange?: boolean;
        returnPartialData?: boolean;
        skipPollAttempt?: () => boolean;
        query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
        [variablesUnknownSymbol]?: boolean;
    } & VariablesOption<NoInfer<TVariables>>;
    // (undocumented)
    export type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache_2.CacheIdentifierOption<TData>;
    // (undocumented)
    export type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
}

// @public
export class ApolloClient {
    // (undocumented)
    __actionHookForDevTools(cb: () => any): void;
    constructor(options: ApolloClient.Options);
    // (undocumented)
    __requestRaw(request: ApolloLink.Request): Observable_2<ApolloLink.Result<unknown>>;
    // (undocumented)
    cache: ApolloCache;
    clearStore(): Promise<any[]>;
    // (undocumented)
    get defaultContext(): Partial<DefaultContext>;
    // (undocumented)
    defaultOptions: ApolloClient.DefaultOptions;
    // (undocumented)
    readonly devtoolsConfig: ApolloClient.DevtoolsOptions;
    // @deprecated (undocumented)
    disableNetworkFetches: never;
    get documentTransform(): DocumentTransform;
    extract(optimistic?: boolean): unknown;
    getMemoryInternals?: typeof getApolloClientMemoryInternals;
    getObservableQueries(include?: RefetchQueriesInclude): Set<ObservableQuery<any>>;
    // (undocumented)
    link: ApolloLink;
    get localState(): LocalState | undefined;
    set localState(localState: LocalState);
    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
    onClearStore(cb: () => Promise<any>): () => void;
    onResetStore(cb: () => Promise<any>): () => void;
    set prioritizeCacheValues(value: boolean);
    get prioritizeCacheValues(): boolean;
    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
    // (undocumented)
    queryDeduplication: boolean;
    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
    // @deprecated
    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadFragmentOptions<TData, TVariables>, optimistic: boolean): Unmasked<TData> | null;
    readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadQueryOptions<TData, TVariables>): Unmasked<TData> | null;
    // @deprecated
    readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadQueryOptions<TData, TVariables>,
    optimistic: boolean): Unmasked<TData> | null;
    // @deprecated
    reFetchObservableQueries: (includeStandby?: boolean) => Promise<ApolloClient.QueryResult<any>[]>;
    refetchObservableQueries(includeStandby?: boolean): Promise<ApolloClient.QueryResult<any>[]>;
    refetchQueries<TCache extends ApolloCache = ApolloCache, TResult = Promise<ApolloClient.QueryResult<any>>>(options: ApolloClient.RefetchQueriesOptions<TCache, TResult>): ApolloClient.RefetchQueriesResult<TResult>;
    resetStore(): Promise<ApolloClient.QueryResult<any>[] | null>;
    restore(serializedState: unknown): ApolloCache;
    setLink(newLink: ApolloLink): void;
    stop(): void;
    subscribe<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.SubscribeOptions<TData, TVariables>): SubscriptionObservable<ApolloClient.SubscribeResult<MaybeMasked<TData>>>;
    // (undocumented)
    version: string;
    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
        from: Array<ApolloCache.FromOptionValue<TData>>;
    }): ApolloClient.ObservableFragment<Array<TData>>;
    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
        from: Array<null>;
    }): ApolloClient.ObservableFragment<Array<null>>;
    // (undocumented)
    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
        from: Array<ApolloCache.FromOptionValue<TData> | null>;
    }): ApolloClient.ObservableFragment<Array<TData | null>>;
    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
        from: null;
    }): ApolloClient.ObservableFragment<null>;
    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
        from: ApolloCache.FromOptionValue<TData>;
    }): ApolloClient.ObservableFragment<TData>;
    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables>): ApolloClient.ObservableFragment<TData | null>;
    watchQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>): ObservableQuery<TData, TVariables>;
    writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WriteFragmentOptions<TData, TVariables>): Reference_2 | undefined;
    writeQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WriteQueryOptions<TData, TVariables>): Reference_2 | undefined;
}

// @public @deprecated (undocumented)
export type ApolloClientOptions = ApolloClient.Options;

export { ApolloLink }

export { ApolloPayloadResult }

// @public @deprecated (undocumented)
export type ApolloQueryResult<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = ObservableQuery.Result<TData, TStates>;

export { ApolloReducerConfig }

// @public (undocumented)
export const build: "source" | "esm" | "cjs";

export { Cache_2 as Cache }

export { checkFetcher }

export { CombinedGraphQLErrors }

export { CombinedProtocolErrors }

export { concat }

export { createHttpLink }

export { createSignalIfSupported }

// @public (undocumented)
export type DataState<TData> = {
    data: DataValue.Complete<TData>;
    dataState: "complete";
} | {
    data: DataValue.Streaming<TData>;
    dataState: "streaming";
} | {
    data: DataValue.Partial<TData>;
    dataState: "partial";
} | {
    data: undefined;
    dataState: "empty";
};

// @public (undocumented)
export namespace DataValue {
    // Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
    export type Complete<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Complete", OverridableTypes.Defaults, TData>;
    export type Partial<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Partial", OverridableTypes.Defaults, TData>;
    export type Streaming<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Streaming", OverridableTypes.Defaults, TData>;
}

// @public (undocumented)
export interface DefaultContext extends Record<string, any> {
    // (undocumented)
    clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
    queryDeduplication?: boolean;
}

export { defaultDataIdFromObject }

// @public @deprecated (undocumented)
export type DefaultOptions = ApolloClient.DefaultOptions;

export { defaultPrinter }

// @public @deprecated (undocumented)
export type DevtoolsOptions = ApolloClient.DevtoolsOptions;

export { DiffQueryAgainstStoreOptions }

export { disableExperimentalFragmentVariables }

export { disableFragmentWarnings }

export { DocumentNode }

export { DocumentTransform }

export { DocumentTransformCacheKey }

export { empty }

export { enableExperimentalFragmentVariables }

// @public
export interface ErrorLike {
    // (undocumented)
    message: string;
    // (undocumented)
    name: string;
    // (undocumented)
    stack?: string;
}

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

export { execute }

export { fallbackHttpConfig }

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

export { FetchResult }

export { FieldFunctionOptions }

export { FieldMergeFunction }

export { FieldPolicy }

export { FieldReadFunction }

export { FragmentType }

export { from }

// @public (undocumented)
export type GetDataState<TData, TState extends DataState<TData>["dataState"]> = Extract<DataState<TData>, {
    dataState: TState;
}>;

export { gql }

export { GraphQLRequest }

export { HttpLink }

export { IdGetter }

export { IdGetterObj }

export { InMemoryCache }

export { InMemoryCacheConfig }

// 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, TResult> extends Omit<ApolloClient.RefetchQueriesOptions<TCache, TResult>, "include"> {
    // (undocumented)
    include?: InternalRefetchQueriesInclude;
    // (undocumented)
    removeOptimistic?: string;
}

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

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

// @internal @deprecated (undocumented)
export namespace InternalTypes {
    export type { NextFetchPolicyContext, QueryManager };
}

export { isNetworkRequestSettled }

export { isReference }

export { LinkError }

export { LocalStateError }

export { makeVar }

// @public (undocumented)
interface MaskFragmentOptions<TData> {
    // (undocumented)
    data: TData;
    // (undocumented)
    fragment: DocumentNode_2;
    // (undocumented)
    fragmentName?: string;
}

// @public (undocumented)
interface MaskOperationOptions<TData> {
    cause?: object;
    // (undocumented)
    data: TData;
    // (undocumented)
    document: DocumentNode_2;
    // (undocumented)
    fetchPolicy?: WatchQueryFetchPolicy;
}

export { MaybeMasked }

export { MergeInfo }

export { MergeTree }

export { MissingFieldError }

// @public @deprecated (undocumented)
export type MutateResult<TData = unknown> = ApolloClient.MutateResult<TData>;

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

// @public @deprecated (undocumented)
export type MutationOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = ApolloClient.MutateOptions<TData, TVariables, TCache>;

// @public (undocumented)
export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
    mutationResult: NormalizedExecutionResult<Unmasked<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_2;
    // (undocumented)
    variables: Record<string, any>;
}

// @public (undocumented)
export type MutationUpdaterFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache> = (cache: TCache, result: FormattedExecutionResult<Unmasked<TData>>, options: {
    context?: DefaultContext;
    variables?: TVariables;
}) => void;

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

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

export { NormalizedCache }

export { NormalizedCacheObject }

// @public
export type NormalizedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = Omit<FormattedExecutionResult<TData, TExtensions>, "data"> & GetDataState<TData, "streaming" | "complete">;

export { Observable }

// @public (undocumented)
interface ObservableAndInfo<TData> {
    // (undocumented)
    fromLink: boolean;
    // Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    observable: Observable_2<QueryNotification.Value<TData>>;
}

// @public (undocumented)
export namespace ObservableQuery {
    // @internal @deprecated
    export interface CacheWatchOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Cache_2.WatchOptions<TData, TVariables> {
        // @deprecated
        lastOwnDiff?: Cache_2.DiffResult<TData>;
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export interface ObservableMethods<TData, OperatorResult> {
            pipe(...operators: OperatorFunctionChain<ObservableQuery.Result<TData>, OperatorResult>): Observable_2<OperatorResult>;
            subscribe(observerOrNext: Partial<Observer<ObservableQuery.Result<MaybeMasked<TData>>>> | ((value: ObservableQuery.Result<MaybeMasked<TData>>) => void)): Subscription;
        }
        // (undocumented)
        export type OperatorFunctionChain<From, To> = [];
    }
    // (undocumented)
    export type FetchMoreOptions<TData, TVariables extends OperationVariables, TFetchData = TData, TFetchVars extends OperationVariables = TVariables> = {
        query?: DocumentNode_2 | TypedDocumentNode<TFetchData, TFetchVars>;
        variables?: Partial<NoInfer<TFetchVars>>;
        errorPolicy?: ErrorPolicy;
        context?: DefaultContext;
        updateQuery?: (previousQueryResult: Unmasked<TData>, options: {
            fetchMoreResult: Unmasked<TFetchData>;
            variables: TFetchVars;
        }) => Unmasked<TData>;
    };
    // (undocumented)
    export type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
        fetchPolicy: WatchQueryFetchPolicy;
        nextFetchPolicy?: WatchQueryFetchPolicy | ((this: ApolloClient.WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
        initialFetchPolicy: WatchQueryFetchPolicy;
        refetchWritePolicy?: RefetchWritePolicy;
        errorPolicy?: ErrorPolicy;
        context?: DefaultContext;
        pollInterval?: number;
        notifyOnNetworkStatusChange?: boolean;
        returnPartialData?: boolean;
        skipPollAttempt?: () => boolean;
        query: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
        variables: TVariables;
    };
    // (undocumented)
    export type Result<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = {
        error?: ErrorLike;
        loading: boolean;
        networkStatus: NetworkStatus;
        partial: boolean;
    } & GetDataState<TData, TStates>;
    export interface ResultPromise<T> extends Promise<T> {
        retain(): this;
    }
    // (undocumented)
    export interface SubscribeToMoreOptions<TData = unknown, TSubscriptionVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData, TVariables extends OperationVariables = TSubscriptionVariables> {
        // (undocumented)
        context?: DefaultContext;
        // (undocumented)
        document: DocumentNode_2 | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>;
        // (undocumented)
        onError?: (error: ErrorLike) => void;
        // (undocumented)
        updateQuery?: SubscribeToMoreUpdateQueryFn<TData, TVariables, TSubscriptionData>;
        // (undocumented)
        variables?: TSubscriptionVariables;
    }
}

// @public (undocumented)
export class ObservableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ObservableQuery.Result<MaybeMasked<TData>>>, InteropObservable<ObservableQuery.Result<MaybeMasked<TData>>> {
    // (undocumented)
    ["@@observable"]: () => Subscribable<ObservableQuery.Result<MaybeMasked<TData>>>;
    // (undocumented)
    [Symbol.observable]: () => Subscribable<ObservableQuery.Result<MaybeMasked<TData>>>;
    constructor({ queryManager, options, transformedQuery, }: {
        queryManager: QueryManager;
        options: ApolloClient.WatchQueryOptions<TData, TVariables>;
        transformedQuery?: DocumentNode_2 | TypedDocumentNode<TData, TVariables>;
        queryId?: string;
    });
    // @internal @deprecated (undocumented)
    applyOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(options: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>): Promise<ApolloClient.QueryResult<TFetchData>>;
    // @internal @deprecated (undocumented)
    getCacheDiff({ optimistic }?: {
        optimistic?: boolean | undefined;
    }): Cache_2.DiffResult<TData>;
    // (undocumented)
    getCurrentResult(): ObservableQuery.Result<MaybeMasked<TData>>;
    // (undocumented)
    hasObservers(): boolean;
    // @internal @deprecated
    _lastWrite?: unknown;
    // @internal @deprecated (undocumented)
    notify(scheduled?: boolean): void;
    // (undocumented)
    readonly options: ObservableQuery.Options<TData, TVariables>;
    pipe: Observable_2<ObservableQuery.Result<MaybeMasked<TData>>>["pipe"];
    // (undocumented)
    get query(): TypedDocumentNode<TData, TVariables>;
    // (undocumented)
    readonly queryName?: string;
    refetch(variables?: Partial<TVariables>): ObservableQuery.ResultPromise<ApolloClient.QueryResult<TData>>;
    reobserve(newOptions?: Partial<ObservableQuery.Options<TData, TVariables>>): ObservableQuery.ResultPromise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
    // @internal @deprecated
    reset(): void;
    setVariables(variables: TVariables): Promise<ApolloClient.QueryResult<TData>>;
    startPolling(pollInterval: number): void;
    stop(): void;
    stopPolling(): void;
    subscribe: (observerOrNext: Partial<Observer<ObservableQuery.Result<MaybeMasked<TData>>>> | ((value: ObservableQuery.Result<MaybeMasked<TData>>) => void)) => Subscription;
    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
    updateQuery(mapFn: UpdateQueryMapFn<TData, TVariables>): void;
    get variables(): TVariables;
}

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

export { Operation }

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

export { OptimisticStoreItem }

// @public (undocumented)
namespace OverridableTypes {
    // (undocumented)
    interface Complete extends HKT {
        // (undocumented)
        arg1: unknown;
        // (undocumented)
        return: this["arg1"];
    }
    // (undocumented)
    interface Defaults {
        // Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
        //
        // (undocumented)
        Complete: Complete;
        // Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
        //
        // (undocumented)
        Partial: Partial;
        // Warning: (ae-forgotten-export) The symbol "OverridableTypes" needs to be exported by the entry point index.d.ts
        //
        // (undocumented)
        Streaming: Streaming;
    }
    // (undocumented)
    interface Partial extends HKT {
        // (undocumented)
        arg1: unknown;
        // (undocumented)
        return: DeepPartial<this["arg1"]>;
    }
    // (undocumented)
    interface Streaming extends HKT {
        // (undocumented)
        arg1: unknown;
        // (undocumented)
        return: this["arg1"];
    }
}

export { parseAndCheckHttpResponse }

export { PossibleTypesMap }

// @public (undocumented)
namespace QueryManager {
    // (undocumented)
    type Result<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = ObservableQuery.Result<TData, TStates> & {
        [extensionsSymbol]?: ExtensionsWithStreamInfo;
    };
}

// @public (undocumented)
class QueryManager {
    // Warning: (ae-forgotten-export) The symbol "QueryManagerOptions" needs to be exported by the entry point index.d.ts
    constructor(options: QueryManagerOptions);
    // (undocumented)
    readonly assumeImmutableResults: boolean;
    // (undocumented)
    broadcastQueries(): void;
    // (undocumented)
    get cache(): ApolloCache;
    // (undocumented)
    clearStore(options?: Cache_2.ResetOptions): Promise<void>;
    // (undocumented)
    readonly client: ApolloClient;
    readonly clientOptions: ApolloClient.Options;
    // (undocumented)
    readonly dataMasking: boolean;
    // (undocumented)
    readonly defaultContext: Partial<DefaultContext>;
    // (undocumented)
    defaultOptions: ApolloClient.DefaultOptions;
    // (undocumented)
    readonly documentTransform: DocumentTransform;
    // (undocumented)
    protected fetchCancelFns: Map<string, (error: any) => any>;
    // Warning: (ae-forgotten-export) The symbol "ObservableAndInfo" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    fetchObservableWithInfo<TData, TVariables extends OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>, { networkStatus, query, fetchQueryOperator, onCacheHit, observableQuery, exposeExtensions, }: {
        networkStatus?: NetworkStatus;
        query?: DocumentNode_2;
        fetchQueryOperator?: <T>(source: Observable_2<T>) => Observable_2<T>;
        onCacheHit?: () => void;
        observableQuery?: ObservableQuery<TData, TVariables> | undefined;
        exposeExtensions?: boolean;
    }): ObservableAndInfo<TData>;
    // (undocumented)
    fetchQuery<TData, TVariables extends OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>, networkStatus?: NetworkStatus): Promise<ApolloClient.QueryResult<TData>>;
    // (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_2): TransformCacheEntry;
    // (undocumented)
    getObservableQueries(include?: InternalRefetchQueriesInclude): Set<ObservableQuery<any, OperationVariables>>;
    // (undocumented)
    getVariables<TVariables extends OperationVariables>(document: DocumentNode_2, variables?: TVariables): TVariables;
    // (undocumented)
    readonly incrementalHandler: Incremental.Handler;
    // (undocumented)
    protected inFlightLinkObservables: Trie<{
        observable?: Observable_2<ApolloLink.Result<any>>;
        restart?: () => void;
    }>;
    // (undocumented)
    get link(): ApolloLink;
    // (undocumented)
    localState: LocalState | undefined;
    // Warning: (ae-forgotten-export) The symbol "MaskFragmentOptions" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    maskFragment<TData = unknown>(options: MaskFragmentOptions<TData>): TData;
    // Warning: (ae-forgotten-export) The symbol "MaskOperationOptions" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    maskOperation<TData = unknown>(options: MaskOperationOptions<TData>): MaybeMasked<TData>;
    // (undocumented)
    mutate<TData, TVariables extends OperationVariables, TCache extends ApolloCache>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: ApolloClient.MutateOptions<TData, TVariables, TCache> & {
        errorPolicy: ErrorPolicy;
        fetchPolicy: MutationFetchPolicy;
    }): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
    // (undocumented)
    mutationStore?: {
        [mutationId: string]: MutationStoreValue;
    };
    obsQueries: Set<ObservableQuery<any, any>>;
    prioritizeCacheValues: boolean;
    // (undocumented)
    query<TData, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
    // (undocumented)
    refetchObservableQueries(includeStandby?: boolean): Promise<ApolloClient.QueryResult<any>[]>;
    // (undocumented)
    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache, TResult>): InternalRefetchQueriesMap<TResult>;
    // (undocumented)
    readonly ssrMode: boolean;
    // (undocumented)
    startGraphQLSubscription<TData = unknown>(options: ApolloClient.SubscribeOptions<TData>): SubscriptionObservable<ApolloClient.SubscribeResult<TData>>;
    stop(): void;
    // (undocumented)
    transform(document: DocumentNode_2): DocumentNode_2;
    // (undocumented)
    watchQuery<TData, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>): ObservableQuery<TData, TVariables>;
}

// @public (undocumented)
interface QueryManagerOptions {
    // (undocumented)
    assumeImmutableResults: boolean;
    // (undocumented)
    client: ApolloClient;
    // (undocumented)
    clientOptions: ApolloClient.Options;
    // (undocumented)
    dataMasking: boolean;
    // (undocumented)
    defaultContext: Partial<DefaultContext> | undefined;
    // (undocumented)
    defaultOptions: ApolloClient.DefaultOptions;
    // (undocumented)
    documentTransform: DocumentTransform | null | undefined;
    // (undocumented)
    incrementalHandler: Incremental.Handler;
    // (undocumented)
    localState: LocalState | undefined;
    // (undocumented)
    onBroadcast: undefined | (() => void);
    // (undocumented)
    queryDeduplication: boolean;
    // (undocumented)
    ssrMode: boolean;
}

// @public (undocumented)
namespace QueryNotification {
    // (undocumented)
    type FromCache<TData> = NextNotification<ObservableQuery.Result<TData>> & {
        source: "cache";
    };
    // (undocumented)
    type FromNetwork<TData> = ObservableNotification<ObservableQuery.Result<TData>> & {
        source: "network";
    };
    // (undocumented)
    type NewNetworkStatus = NextNotification<{
        resetError?: boolean;
    }> & {
        source: "newNetworkStatus";
    };
    // (undocumented)
    type SetResult<TData> = NextNotification<ObservableQuery.Result<TData>> & {
        source: "setResult";
    };
    // Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "QueryNotification" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    type Value<TData> = FromCache<TData> | FromNetwork<TData> | NewNetworkStatus | SetResult<TData>;
}

// @public @deprecated (undocumented)
export type QueryOptions<TVariables extends OperationVariables = OperationVariables, TData = unknown> = ApolloClient.QueryOptions<TData, TVariables>;

export { ReactiveVar }

export { ReadMergeModifyContext }

export { ReadQueryOptions }

export { Reference }

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

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

// @public @deprecated (undocumented)
export type RefetchQueriesOptions<TCache extends ApolloCache, TResult> = ApolloClient.RefetchQueriesOptions<TCache, TResult>;

// @public (undocumented)
export type RefetchQueriesPromiseResults<TResult> = IsAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloClient.QueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];

// @public @deprecated (undocumented)
export type RefetchQueriesResult<TResult> = ApolloClient.RefetchQueriesResult<TResult>;

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

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

export { RequestHandler }

export { resetCaches }

export { rewriteURIForGET }

export { selectHttpOptionsAndBody }

export { selectHttpOptionsAndBodyInternal }

export { selectURI }

export { ServerError }

export { ServerParseError }

export { setLogVerbosity }

export { split }

export { StoreObject }

export { StoreValue }

// @public (undocumented)
export interface SubscribeToMoreFunction<TData, TVariables extends OperationVariables = OperationVariables> {
    // (undocumented)
    <TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
}

// @public @deprecated (undocumented)
export type SubscribeToMoreOptions<TData = unknown, TSubscriptionVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData, TVariables extends OperationVariables = TSubscriptionVariables> = ObservableQuery.SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>;

// @public (undocumented)
export type SubscribeToMoreUpdateQueryFn<TData = unknown, TVariables extends OperationVariables = OperationVariables, TSubscriptionData = TData> = {
    (
    unsafePreviousData: DeepPartial<Unmasked<TData>>, options: UpdateQueryOptions<TData, TVariables> & {
        subscriptionData: {
            data: Unmasked<TSubscriptionData>;
        };
    }): Unmasked<TData> | void;
};

// @public
export interface SubscriptionObservable<T> extends Observable_2<T> {
    restart: () => void;
}

// @public @deprecated (undocumented)
export type SubscriptionOptions<TVariables extends OperationVariables = OperationVariables, TData = unknown> = ApolloClient.SubscribeOptions<TData, TVariables>;

export { Transaction }

// @public (undocumented)
interface TransformCacheEntry {
    // (undocumented)
    asQuery: DocumentNode_2;
    // (undocumented)
    clientQuery: DocumentNode_2 | null;
    // (undocumented)
    defaultVars: OperationVariables;
    // (undocumented)
    hasClientExports: boolean;
    // (undocumented)
    hasForcedResolvers: boolean;
    // (undocumented)
    hasIncrementalDirective: boolean;
    // (undocumented)
    hasNonreactiveDirective: boolean;
    // (undocumented)
    nonReactiveQuery: DocumentNode_2;
    // (undocumented)
    operationType: OperationTypeNode | undefined;
    // (undocumented)
    serverQuery: DocumentNode_2 | null;
    // (undocumented)
    violation?: Error | undefined;
}

export { TypedDocumentNode }

// @public (undocumented)
export interface TypeOverrides {
}

export { TypePolicies }

export { TypePolicy }

export { UnconventionalError }

export { Unmasked }

// @public (undocumented)
export interface UpdateQueryMapFn<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
    // (undocumented)
    (
    unsafePreviousData: DeepPartial<Unmasked<TData>>, options: UpdateQueryOptions<TData, TVariables>): Unmasked<TData> | void;
}

// @public (undocumented)
export type UpdateQueryOptions<TData, TVariables extends OperationVariables> = {
    variables?: TVariables;
} & ({
    complete: true;
    previousData: Unmasked<TData>;
} | {
    complete: false;
    previousData: DeepPartial<Unmasked<TData>> | undefined;
});

// @public (undocumented)
export const version: string;

export { WatchFragmentOptions }

export { WatchFragmentResult }

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

// @public @deprecated (undocumented)
export type WatchQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = unknown> = ApolloClient.WatchQueryOptions<TData, TVariables>;

// Warnings were encountered during analysis:
//
// src/core/ApolloClient.ts:375:5 - (ae-forgotten-export) The symbol "NextFetchPolicyContext" needs to be exported by the entry point index.d.ts
// src/core/ObservableQuery.ts:371:5 - (ae-forgotten-export) The symbol "QueryManager" needs to be exported by the entry point index.d.ts
// src/core/QueryManager.ts:195:5 - (ae-forgotten-export) The symbol "MutationStoreValue" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)