Api Report React.Api

import type { ApolloCache } from '@apollo/client';
import type { ApolloCache as ApolloCache_2 } from '@apollo/client/cache';
import type { ApolloClient } from '@apollo/client';
import type { DataState } from '@apollo/client';
import type { DataValue } from '@apollo/client';
import type { DefaultContext } from '@apollo/client';
import type { DocumentationTypes } from '@apollo/client/utilities/internal';
import type { DocumentNode } from 'graphql';
import type { DocumentNode as DocumentNode_2 } from '@apollo/client';
import type { ErrorLike } from '@apollo/client';
import type { ErrorPolicy } from '@apollo/client';
import type { FetchMoreFunction } from '@apollo/client/react/internal';
import type { FetchPolicy } from '@apollo/client';
import type { GetDataState } from '@apollo/client';
import type { HookWrappers } from '@apollo/client/react/internal';
import type { IgnoreModifier } from '@apollo/client/cache';
import type { InternalRefetchQueriesInclude } from '@apollo/client';
import type { InternalTypes as InternalTypes_2 } from '@apollo/client';
import type { MaybeMasked } from '@apollo/client';
import type { MaybeMasked as MaybeMasked_2 } from '@apollo/client/masking';
import type { MissingTree } from '@apollo/client/cache';
import type { MutationFetchPolicy } from '@apollo/client';
import type { MutationQueryReducersMap } from '@apollo/client';
import type { MutationUpdaterFunction } from '@apollo/client';
import { NetworkStatus } from '@apollo/client';
import type { NoInfer as NoInfer_2 } from '@apollo/client/utilities/internal';
import type { NormalizedExecutionResult } from '@apollo/client';
import type { ObservableQuery } from '@apollo/client';
import type { OnQueryUpdated } from '@apollo/client';
import type { OperationVariables } from '@apollo/client';
import { PreloadedQueryRef } from '@apollo/client/react/internal';
import type { PreloadedQueryRef as PreloadedQueryRef_2 } from '@apollo/client/react';
import type { Prettify } from '@apollo/client/utilities/internal';
import { QueryRef } from '@apollo/client/react/internal';
import type { QueryRef as QueryRef_2 } from '@apollo/client/react';
import type { ReactiveVar } from '@apollo/client';
import type * as ReactTypes from 'react';
import type { RefetchFunction } from '@apollo/client/react/internal';
import type { RefetchWritePolicy } from '@apollo/client';
import type { SubscribeToMoreFunction } from '@apollo/client';
import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
import type { TypedDocumentNode as TypedDocumentNode_2 } from '@apollo/client';
import type { Unmasked } from '@apollo/client';
import type { UpdateQueryMapFn } from '@apollo/client';
import type { VariablesOption } from '@apollo/client/utilities/internal';
import type { WatchQueryFetchPolicy } from '@apollo/client';
import type { wrapperSymbol } from '@apollo/client/react/internal';

// @public (undocumented)
export interface ApolloContextValue {
    // (undocumented)
    [wrapperSymbol]?: HookWrappers;
    // (undocumented)
    client?: ApolloClient;
}

// @public (undocumented)
export namespace ApolloProvider {
    // (undocumented)
    export interface Props {
        // (undocumented)
        children: ReactTypes.ReactNode | ReactTypes.ReactNode[] | null;
        // (undocumented)
        client: ApolloClient;
    }
}

// @public (undocumented)
export const ApolloProvider: ReactTypes.FC<ApolloProvider.Props>;

// @public @deprecated (undocumented)
export type BackgroundQueryHookFetchPolicy = useBackgroundQuery.FetchPolicy;

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

// @public
export function createQueryPreloader(client: ApolloClient): PreloadQueryFunction;

// @public (undocumented)
export function getApolloContext(): ReactTypes.Context<ApolloContextValue>;

// @internal @deprecated (undocumented)
export namespace InternalTypes {
    export type { HookWrappers };
}

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

// @public @deprecated (undocumented)
export type LazyQueryHookExecOptions<TVariables extends OperationVariables = OperationVariables> = useLazyQuery.ExecOptions<TVariables>;

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

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

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

// @public @deprecated (undocumented)
export type LoadableQueryFetchPolicy = useLoadableQuery.FetchPolicy;

// @public @deprecated (undocumented)
export type LoadableQueryHookOptions = useLoadableQuery.Options;

// @public @deprecated (undocumented)
export type LoadQueryFunction<TVariables extends OperationVariables> = useLoadableQuery.LoadQueryFunction<TVariables>;

// @public (undocumented)
type MakeRequiredVariablesOptional<TVariables extends OperationVariables, TConfiguredVariables extends Partial<TVariables>> = Prettify<{
    [K in keyof TVariables as K extends keyof TConfiguredVariables ? K : never]?: TVariables[K];
} & Omit<TVariables, keyof TConfiguredVariables>>;

// @public @deprecated (undocumented)
export type MutationFunctionOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, _TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = useMutation.MutationFunctionOptions<TData, TVariables, TCache>;

// @public @deprecated (undocumented)
export type MutationHookOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, _TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = useMutation.Options<TData, TVariables, TCache>;

// @public @deprecated (undocumented)
export type MutationResult<TData = unknown> = useMutation.Result<TData>;

// @public @deprecated (undocumented)
export type MutationTuple<TData, TVariables extends OperationVariables, _TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = useMutation.ResultTuple<TData, TVariables, TCache>;

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

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

export { PreloadedQueryRef }

// @public (undocumented)
export type PreloadQueryFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;

// @public
export interface PreloadQueryFunction {
    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: PreloadQueryOptions<NoInfer_2<TVariables>> & {
        returnPartialData: true;
        errorPolicy: "ignore" | "all";
    }): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: PreloadQueryOptions<NoInfer_2<TVariables>> & {
        errorPolicy: "ignore" | "all";
    }): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming" | "empty">;
    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: PreloadQueryOptions<NoInfer_2<TVariables>> & {
        returnPartialData: true;
    }): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming" | "partial">;
    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
    options?: PreloadQueryOptions<NoInfer_2<TVariables>>
    ] : [options: PreloadQueryOptions<NoInfer_2<TVariables>>]): PreloadedQueryRef_2<TData, TVariables, "complete" | "streaming">;
    toPromise<TQueryRef extends PreloadedQueryRef_2<any, any, any>>(queryRef: TQueryRef): Promise<TQueryRef>;
}

// @public (undocumented)
export type PreloadQueryOptions<TVariables extends OperationVariables = OperationVariables> = {
    context?: DefaultContext;
    errorPolicy?: ErrorPolicy;
    fetchPolicy?: PreloadQueryFetchPolicy;
    returnPartialData?: boolean;
    refetchWritePolicy?: RefetchWritePolicy;
} & VariablesOption<TVariables>;

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

export { QueryRef }

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

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

// @public (undocumented)
type ResetFunction = () => void;

// @public (undocumented)
export type SkipToken = typeof skipToken;

// @public (undocumented)
export const skipToken: unique symbol;

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

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

// @public @deprecated (undocumented)
export type SuspenseQueryHookFetchPolicy = useSuspenseQuery.FetchPolicy;

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

// @public (undocumented)
export function useApolloClient(override?: ApolloClient): ApolloClient;

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
    fetchPolicy: "no-cache";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: false;
    errorPolicy: "ignore" | "all";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "empty">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
    errorPolicy: "ignore" | "all";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial" | "empty">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    errorPolicy: "ignore" | "all";
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "empty">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    skip: boolean;
    returnPartialData: false;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    skip: boolean;
    returnPartialData: boolean;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: false;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    skip: boolean;
}): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken): [undefined, useBackgroundQuery.Result<TData, TVariables>];

// @public
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: false;
})): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
})): [
QueryRef_2<TData, TVariables, "complete" | "streaming" | "partial"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: useBackgroundQuery.Options<NoInfer_2<TVariables>>
] : [options: useBackgroundQuery.Options<NoInfer_2<TVariables>>]): [
QueryRef_2<TData, TVariables, "complete" | "streaming">,
useBackgroundQuery.Result<TData, TVariables>
];

// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: SkipToken | useBackgroundQuery.Options<NoInfer_2<TVariables>>
] : [options: SkipToken | useBackgroundQuery.Options<NoInfer_2<TVariables>>]): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public (undocumented)
export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<NoInfer_2<TVariables>>): [
QueryRef_2<TData, TVariables, "complete" | "streaming"> | undefined,
useBackgroundQuery.Result<TData, TVariables>
];

// @public (undocumented)
export namespace useBackgroundQuery {
    import _self = useBackgroundQuery;
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Options {
            client?: ApolloClient;
            context?: DefaultContext;
            errorPolicy?: ErrorPolicy;
            fetchPolicy?: FetchPolicy;
            queryKey?: string | number | any[];
            refetchWritePolicy?: RefetchWritePolicy;
            returnPartialData?: boolean;
            // @deprecated
            skip?: boolean;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useBackgroundQuery {
            // (undocumented)
            export interface Options<TVariables extends OperationVariables = OperationVariables> extends Base.Options, DocumentationTypes.VariableOptions<TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useBackgroundQuery {
            // (undocumented)
            export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends useBackgroundQuery.Result<TData, TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<TVariables>): [
        QueryRef_2<TData, TVariables> | undefined,
        useBackgroundQuery.Result<TData, TVariables>
        ];
    }
    // (undocumented)
    export type FetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
    // (undocumented)
    export type Options<TVariables extends OperationVariables = OperationVariables> = Base.Options & VariablesOption<TVariables>;
    // (undocumented)
    export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
        fetchMore: FetchMoreFunction<TData, TVariables>;
        refetch: RefetchFunction<TData, TVariables>;
        subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
    }
}

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

// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables> & {
    from: Array<useFragment.FromOptionValue<TData>>;
}): useFragment.Result<Array<TData>>;

// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables> & {
    from: Array<null>;
}): useFragment.Result<Array<null>>;

// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables> & {
    from: Array<useFragment.FromOptionValue<TData> | null>;
}): useFragment.Result<Array<TData | null>>;

// @public
export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useFragment.Options<TData, TVariables>): useFragment.Result<TData>;

// @public (undocumented)
export namespace useFragment {
    import _self = useFragment;
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useFragment {
            // (undocumented)
            export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends useFragment.Options<TData, TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useFragment {
            // (undocumented)
            export interface Result<TData> {
                // (undocumented)
                complete: boolean;
                // (undocumented)
                data: MaybeMasked_2<TData> | DataValue.Partial<MaybeMasked_2<TData>>;
                missing?: MissingTree;
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, from, fragmentName, variables, optimistic, client, }: useFragment.Options<TData, TVariables>): useFragment.Result<TData>;
    }
    export type FromOptionValue<TData> = ApolloCache_2.FromOptionValue<TData>;
    // (undocumented)
    export interface Options<TData, TVariables extends OperationVariables> {
        client?: ApolloClient;
        fragment: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>;
        fragmentName?: string;
        from: useFragment.FromOptionValue<TData> | Array<useFragment.FromOptionValue<TData> | null> | null;
        optimistic?: boolean;
        variables?: NoInfer_2<TVariables>;
    }
    // (undocumented)
    export type Result<TData> = ({
        complete: true;
        missing?: never;
    } & GetDataState<MaybeMasked_2<TData>, "complete">) | {
        complete: false;
        missing?: MissingTree;
        data: TData extends Array<infer TItem> ? Array<DataValue.Partial<TItem> | null> : DataValue.Partial<TData>;
        dataState: "partial";
    };
}

// @public @deprecated (undocumented)
export type UseFragmentOptions<TData, TVariables extends OperationVariables> = useFragment.Options<TData, TVariables>;

// @public @deprecated (undocumented)
export type UseFragmentResult<TData> = useFragment.Result<TData>;

// @public
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
    returnPartialData: true;
}): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;

// @public
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
}): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;

// @public
export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useLazyQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming">;

// @public (undocumented)
export namespace useLazyQuery {
    import _self = useLazyQuery;
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Result<TData, TVariables extends OperationVariables> {
            client: ApolloClient;
            error?: ErrorLike;
            fetchMore: <TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>) => Promise<ApolloClient.QueryResult<MaybeMasked<TFetchData>>>;
            loading: boolean;
            networkStatus: NetworkStatus;
            observable: ObservableQuery<TData, TVariables>;
            previousData?: MaybeMasked<TData>;
            refetch: (variables?: Partial<TVariables>) => Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
            startPolling: (pollInterval: number) => void;
            stopPolling: () => void;
            subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
            updateQuery: (mapFn: UpdateQueryMapFn<TData, TVariables>) => void;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useLazyQuery {
            // (undocumented)
            export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends useLazyQuery.Options<TData, TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useLazyQuery {
            // (undocumented)
            export interface Result<TData, TVariables extends OperationVariables> extends Base.Result<TData, TVariables>, DocumentationTypes.DataState<TData>, DocumentationTypes.VariableOptions<TVariables> {
                called: boolean;
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useLazyQuery {
            // (undocumented)
            export interface ExecOptions<TVariables extends OperationVariables> extends DocumentationTypes.VariableOptions<TVariables> {
                context?: DefaultContext;
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useLazyQuery {
            import ResultTuple = _self.ResultTuple;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<TData, TVariables>): useLazyQuery.ResultTuple<TData, TVariables>;
    }
    // (undocumented)
    export type ExecFunction<TData, TVariables extends OperationVariables> = (...args: {} extends TVariables ? [
    options?: useLazyQuery.ExecOptions<TVariables>
    ] : [options: useLazyQuery.ExecOptions<TVariables>]) => ObservableQuery.ResultPromise<ApolloClient.QueryResult<TData>>;
    // (undocumented)
    export type ExecOptions<TVariables extends OperationVariables = OperationVariables> = {
        context?: DefaultContext;
    } & VariablesOption<TVariables>;
    // (undocumented)
    export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
        client?: ApolloClient;
        errorPolicy?: ErrorPolicy;
        fetchPolicy?: WatchQueryFetchPolicy;
        nextFetchPolicy?: WatchQueryFetchPolicy | ((this: ApolloClient.WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: InternalTypes_2.NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
        notifyOnNetworkStatusChange?: boolean;
        pollInterval?: number;
        refetchWritePolicy?: RefetchWritePolicy;
        returnPartialData?: boolean;
        skipPollAttempt?: () => boolean;
    }
    // (undocumented)
    export type Result<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData, TVariables> & (({
        called: true;
        variables: TVariables;
    } & GetDataState<MaybeMasked<TData>, TStates>) | {
        called: false;
        variables: Partial<TVariables>;
        data: undefined;
        dataState: "empty";
    });
    // (undocumented)
    export type ResultTuple<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = [
    execute: ExecFunction<TData, TVariables>,
    result: useLazyQuery.Result<TData, TVariables, TStates>
    ];
}

// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options & {
    returnPartialData: true;
    errorPolicy: "ignore" | "all";
}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;

// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options & {
    errorPolicy: "ignore" | "all";
}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;

// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options & {
    returnPartialData: true;
}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial">;

// @public
export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options?: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming">;

// @public (undocumented)
export namespace useLoadableQuery {
    // (undocumented)
    export namespace DocumentationTypes {
        export function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables>;
    }
    // (undocumented)
    export type FetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
    // (undocumented)
    export interface Handlers<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
        fetchMore: FetchMoreFunction<TData, TVariables>;
        refetch: RefetchFunction<TData, TVariables>;
        // Warning: (ae-forgotten-export) The symbol "ResetFunction" needs to be exported by the entry point index.d.ts
        reset: ResetFunction;
        subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
    }
    // (undocumented)
    export type LoadQueryFunction<TVariables extends OperationVariables> = (...args: {} extends TVariables ? [variables?: TVariables] : [variables: TVariables]) => void;
    // (undocumented)
    export interface Options {
        client?: ApolloClient;
        context?: DefaultContext;
        errorPolicy?: ErrorPolicy;
        fetchPolicy?: FetchPolicy;
        queryKey?: string | number | any[];
        refetchWritePolicy?: RefetchWritePolicy;
        returnPartialData?: boolean;
    }
    // (undocumented)
    export type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = [
    loadQuery: LoadQueryFunction<TVariables>,
    queryRef: QueryRef_2<TData, TVariables, TStates> | null,
    handlers: Handlers<TData, TVariables>
    ];
}

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

// Warning: (ae-forgotten-export) The symbol "MakeRequiredVariablesOptional" needs to be exported by the entry point index.d.ts
//
// @public
export function useMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TConfiguredVariables extends Partial<TVariables> = {}>(mutation: DocumentNode_2 | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<NoInfer_2<TData>, NoInfer_2<TVariables>, TCache, {
    [K in keyof TConfiguredVariables]: K extends keyof TVariables ? TConfiguredVariables[K] : never;
}>): useMutation.ResultTuple<TData, MakeRequiredVariablesOptional<TVariables, TConfiguredVariables>, TCache>;

// @public (undocumented)
export namespace useMutation {
    // (undocumented)
    export namespace DocumentationTypes {
        export function useMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables>(mutation: DocumentNode_2 | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<TData, TVariables>): useMutation.ResultTuple<TData, TVariables>;
    }
    // (undocumented)
    export type MutationFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache = ApolloCache> = (...[options]: {} extends TVariables ? [
    options?: MutationFunctionOptions<TData, TVariables, TCache> & {
        variables?: TVariables;
    }
    ] : [
    options: MutationFunctionOptions<TData, TVariables, TCache> & {
        variables: TVariables;
    }
    ]) => Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
    // (undocumented)
    export type MutationFunctionOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = Options<TData, TVariables, TCache> & {
        context?: DefaultContext | ((hookContext: DefaultContext | undefined) => DefaultContext);
    };
    // (undocumented)
    export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TConfiguredVariables extends Partial<TVariables> = Partial<TVariables>> {
        awaitRefetchQueries?: boolean;
        client?: ApolloClient;
        context?: DefaultContext;
        errorPolicy?: ErrorPolicy;
        fetchPolicy?: MutationFetchPolicy;
        keepRootFields?: boolean;
        notifyOnNetworkStatusChange?: boolean;
        onCompleted?: (data: MaybeMasked<TData>, clientOptions?: Options<TData, TVariables, TCache>) => void;
        onError?: (error: ErrorLike, clientOptions?: Options<TData, TVariables, TCache>) => void;
        onQueryUpdated?: OnQueryUpdated<any>;
        optimisticResponse?: Unmasked<NoInfer_2<TData>> | ((vars: TVariables, { IGNORE }: {
            IGNORE: IgnoreModifier;
        }) => Unmasked<NoInfer_2<TData>> | IgnoreModifier);
        refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
        update?: MutationUpdaterFunction<TData, TVariables, TCache>;
        updateQueries?: MutationQueryReducersMap<TData>;
        variables?: Partial<TVariables> & TConfiguredVariables;
    }
    // (undocumented)
    export interface Result<TData = unknown> {
        called: boolean;
        client: ApolloClient;
        data: MaybeMasked<TData> | null | undefined;
        error: ErrorLike | undefined;
        loading: boolean;
        reset: () => void;
    }
    // (undocumented)
    export type ResultTuple<TData, TVariables extends OperationVariables, TCache extends ApolloCache = ApolloCache> = [
    mutate: MutationFunction<TData, TVariables, TCache>,
    result: Result<TData>
    ];
}

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
    returnPartialData: true;
}): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
    returnPartialData: true;
})): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
}): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>> & {
    returnPartialData: boolean;
})): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>
] : [options: useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming">;

// @public
export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: SkipToken | useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>
] : [options: SkipToken | useQuery.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming", Partial<TVariables>>;

// @public (undocumented)
export namespace useQuery {
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
            client?: ApolloClient;
            context?: DefaultContext;
            errorPolicy?: ErrorPolicy;
            fetchPolicy?: WatchQueryFetchPolicy;
            initialFetchPolicy?: WatchQueryFetchPolicy;
            nextFetchPolicy?: WatchQueryFetchPolicy | ((this: ApolloClient.WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: InternalTypes_2.NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
            notifyOnNetworkStatusChange?: boolean;
            pollInterval?: number;
            refetchWritePolicy?: RefetchWritePolicy;
            returnPartialData?: boolean;
            skip?: boolean;
            skipPollAttempt?: () => boolean;
            ssr?: boolean;
        }
    }
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TReturnVariables extends OperationVariables = TVariables> {
            client: ApolloClient;
            error?: ErrorLike;
            fetchMore: <TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(fetchMoreOptions: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>) => Promise<ApolloClient.QueryResult<MaybeMasked_2<TFetchData>>>;
            loading: boolean;
            networkStatus: NetworkStatus;
            observable: ObservableQuery<TData, TVariables>;
            previousData?: MaybeMasked_2<TData>;
            refetch: (variables?: Partial<TVariables>) => Promise<ApolloClient.QueryResult<MaybeMasked_2<TData>>>;
            startPolling: (pollInterval: number) => void;
            stopPolling: () => void;
            subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
            updateQuery: (mapFn: UpdateQueryMapFn<TData, TVariables>) => void;
            variables: TReturnVariables;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useQuery {
            // (undocumented)
            export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Options<TData, TVariables>, DocumentationTypes.VariableOptions<TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useQuery {
            // (undocumented)
            export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Result<TData, TVariables>, DocumentationTypes.DataState<TData> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
    }
    // (undocumented)
    export type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = Base.Options<TData, TVariables> & VariablesOption<TVariables>;
    // (undocumented)
    export type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"], TReturnVariables extends OperationVariables = TVariables> = Base.Result<TData, TVariables, TReturnVariables> & GetDataState<MaybeMasked_2<TData>, TStates>;
}

// @public (undocumented)
export namespace useQuery {
    var // (undocumented)
    ssrDisabledResult: ObservableQuery.Result<any, "complete" | "streaming" | "partial" | "empty">;
}

// @public
export function useQueryRefHandlers<TData = unknown, TVariables extends OperationVariables = OperationVariables>(queryRef: QueryRef_2<TData, TVariables, DataState<TData>["dataState"]>): useQueryRefHandlers.Result<TData, TVariables>;

// @public (undocumented)
export namespace useQueryRefHandlers {
    // (undocumented)
    export namespace DocumentationTypes {
        export function useQueryRefHandlers<TData = unknown, TVariables extends OperationVariables = OperationVariables>(queryRef: QueryRef_2<TData, TVariables>): useQueryRefHandlers.Result<TData, TVariables>;
    }
    // (undocumented)
    export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
        fetchMore: FetchMoreFunction<TData, TVariables>;
        refetch: RefetchFunction<TData, TVariables>;
        subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
    }
}

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

// @public
export function useReactiveVar<T>(rv: ReactiveVar<T>): T;

// @public
export function useReadQuery<TData, TStates extends DataState<TData>["dataState"]>(queryRef: QueryRef_2<TData, any, TStates>): useReadQuery.Result<TData, TStates>;

// @public (undocumented)
export namespace useReadQuery {
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Result<TData = unknown> {
            error: ErrorLike | undefined;
            networkStatus: NetworkStatus;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useReadQuery {
            // (undocumented)
            export interface Result<TData = unknown> extends Base.Result<TData>, DocumentationTypes.DataState<TData> {
            }
        }
        export function useReadQuery<TData>(queryRef: QueryRef_2<TData>): useReadQuery.Result<TData>;
    }
    // (undocumented)
    export type Result<TData = unknown, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData> & GetDataState<MaybeMasked_2<TData>, TStates>;
}

// @public @deprecated (undocumented)
export type UseReadQueryResult<TData = unknown> = useReadQuery.Result<TData>;

// @public
export function useSubscription<TData = unknown, TVariables extends OperationVariables = OperationVariables>(subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends (TVariables) ? [
options?: useSubscription.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>
] : [options: useSubscription.Options<NoInfer_2<TData>, NoInfer_2<TVariables>>]): useSubscription.Result<TData>;

// @public (undocumented)
export namespace useSubscription {
    import _self = useSubscription;
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
            client?: ApolloClient;
            context?: DefaultContext;
            errorPolicy?: ErrorPolicy;
            extensions?: Record<string, any>;
            fetchPolicy?: FetchPolicy;
            ignoreResults?: boolean;
            onComplete?: () => void;
            onData?: (options: OnDataOptions<TData>) => any;
            onError?: (error: ErrorLike) => void;
            shouldResubscribe?: boolean | ((options: Options<TData, TVariables>) => boolean);
            skip?: boolean;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useSubscription {
            // (undocumented)
            export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Options<TData, TVariables>, DocumentationTypes.VariableOptions<TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useSubscription {
            // (undocumented)
            export interface Result<TData = unknown> extends useSubscription.Result<TData> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useSubscription<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options?: useSubscription.Options<TData, TVariables>): useSubscription.Result<TData>;
    }
    // (undocumented)
    export interface OnDataOptions<TData = unknown> {
        // (undocumented)
        client: ApolloClient;
        // (undocumented)
        data: OnDataResult<TData>;
    }
    // (undocumented)
    export type OnDataResult<TData = unknown> = Omit<Result<TData>, "restart">;
    // (undocumented)
    export interface OnSubscriptionDataOptions<TData = unknown> {
        // (undocumented)
        client: ApolloClient;
        // (undocumented)
        subscriptionData: OnDataResult<TData>;
    }
    // (undocumented)
    export type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = Base.Options<TData, TVariables> & VariablesOption<TVariables>;
    // (undocumented)
    export interface Result<TData = unknown> {
        data?: MaybeMasked_2<TData>;
        error?: ErrorLike;
        loading: boolean;
        restart: () => void;
    }
}

// @public
export function useSuspenseFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
    from: Array<useSuspenseFragment.FromOptionValue<TData>>;
}): useSuspenseFragment.Result<Array<TData>>;

// @public
export function useSuspenseFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
    from: Array<null>;
}): useSuspenseFragment.Result<Array<null>>;

// @public
export function useSuspenseFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
    from: Array<useSuspenseFragment.FromOptionValue<TData> | null>;
}): useSuspenseFragment.Result<Array<TData | null>>;

// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
    from: useSuspenseFragment.FromOptionValue<TData>;
}): useSuspenseFragment.Result<TData>;

// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
    from: null;
}): useSuspenseFragment.Result<null>;

// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables> & {
    from: useSuspenseFragment.FromOptionValue<TData> | null;
}): useSuspenseFragment.Result<TData | null>;

// @public
export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables>): useSuspenseFragment.Result<TData>;

// @public (undocumented)
export namespace useSuspenseFragment {
    import _self = useSuspenseFragment;
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export type Options<TData, TVariables extends OperationVariables> = {
            fragment: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>;
            fragmentName?: string;
            from: useSuspenseFragment.FromOptionValue<TData> | Array<useSuspenseFragment.FromOptionValue<TData> | null> | null;
            optimistic?: boolean;
            client?: ApolloClient;
        };
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useSuspenseFragment {
            // (undocumented)
            export interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Options<TData, TVariables>, DocumentationTypes.VariableOptions<TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useSuspenseFragment {
            // (undocumented)
            export interface Result<TData = unknown> extends useSuspenseFragment.Result<TData> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useSuspenseFragment<TData, TVariables extends OperationVariables = OperationVariables>(options: useSuspenseFragment.Options<TData, TVariables>): useSuspenseFragment.Result<TData>;
    }
    export type FromOptionValue<TData> = ApolloCache_2.FromOptionValue<TData>;
    // (undocumented)
    export type Options<TData, TVariables extends OperationVariables> = Base.Options<TData, TVariables> & VariablesOption<NoInfer_2<TVariables>>;
    // (undocumented)
    export interface Result<TData> {
        // (undocumented)
        data: DataValue.Complete<MaybeMasked_2<TData>>;
    }
}

// @public @deprecated (undocumented)
export type UseSuspenseFragmentOptions<TData, TVariables extends OperationVariables> = useSuspenseFragment.Options<TData, TVariables>;

// @public @deprecated (undocumented)
export type UseSuspenseFragmentResult<TData> = useSuspenseFragment.Result<TData>;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: true;
    errorPolicy: "ignore" | "all";
}): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer_2<TVariables>> & {
    errorPolicy: "ignore" | "all";
}): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer_2<TVariables>> & {
    skip: boolean;
    returnPartialData: true;
}): useSuspenseQuery.Result<TData, TVariables, "complete" | "empty" | "streaming" | "partial">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: true;
}): useSuspenseQuery.Result<TData, TVariables, "partial" | "streaming" | "complete">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer_2<TVariables>> & {
    skip: boolean;
}): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | (useSuspenseQuery.Options<NoInfer_2<TVariables>> & {
    returnPartialData: true;
})): useSuspenseQuery.Result<TData, TVariables, "empty" | "streaming" | "complete" | "partial">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: useSuspenseQuery.Options<NoInfer_2<TVariables>>
] : [options: useSuspenseQuery.Options<NoInfer_2<TVariables>>]): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, ...[options]: {} extends TVariables ? [
options?: SkipToken | useSuspenseQuery.Options<NoInfer_2<TVariables>>
] : [options: SkipToken | useSuspenseQuery.Options<NoInfer_2<TVariables>>]): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;

// @public
export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options: SkipToken | useSuspenseQuery.Options<NoInfer_2<TVariables>>): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;

// @public (undocumented)
export namespace useSuspenseQuery {
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Options<TVariables extends OperationVariables = OperationVariables> {
            client?: ApolloClient;
            context?: DefaultContext;
            errorPolicy?: ErrorPolicy;
            fetchPolicy?: FetchPolicy;
            queryKey?: string | number | any[];
            refetchWritePolicy?: RefetchWritePolicy;
            returnPartialData?: boolean;
            // @deprecated
            skip?: boolean;
        }
    }
    // (undocumented)
    export namespace Base {
        // (undocumented)
        export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
            client: ApolloClient;
            error: ErrorLike | undefined;
            fetchMore: FetchMoreFunction<TData, TVariables>;
            networkStatus: NetworkStatus;
            refetch: RefetchFunction<TData, TVariables>;
            subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useSuspenseQuery {
            // (undocumented)
            export interface Options<TVariables extends OperationVariables = OperationVariables> extends Base.Options<TVariables>, DocumentationTypes.VariableOptions<TVariables> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        // (undocumented)
        export namespace useSuspenseQuery {
            // (undocumented)
            export interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Result<TData, TVariables>, DocumentationTypes.DataState<TData> {
            }
        }
    }
    // (undocumented)
    export namespace DocumentationTypes {
        export function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode_2 | TypedDocumentNode_2<TData, TVariables>, options?: useSuspenseQuery.Options<TVariables>): useSuspenseQuery.Result<TData, TVariables>;
    }
    // (undocumented)
    export type FetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
    // (undocumented)
    export type Options<TVariables extends OperationVariables = OperationVariables> = Base.Options<TVariables> & VariablesOption<TVariables>;
    // (undocumented)
    export type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData, TVariables> & GetDataState<MaybeMasked<TData>, TStates>;
}

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

// (No @packageDocumentation comment for this package)