import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, OperationVariables, RefetchOn, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
import type { PreloadedQueryRef } from "@apollo/client/react";
import type { NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
export type PreloadQueryFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
export type PreloadQueryOptions<TVariables extends OperationVariables = OperationVariables> = {
    /**
    * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
    * 
    * @docGroup 2. Networking options
    */
    context?: DefaultContext;
    /**
    * Specifies how the query handles a response that returns both GraphQL errors and partial results.
    * 
    * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
    * 
    * The default value is `none`, meaning that the query result includes error details but not partial results.
    * 
    * @docGroup 1. Operation options
    */
    errorPolicy?: ErrorPolicy;
    /**
    * Specifies how the query interacts with the Apollo Client cache during execution (for example, whether it checks the cache for results before sending a request to the server).
    * 
    * For details, see [Setting a fetch policy](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy).
    * 
    * The default value is `cache-first`.
    * 
    * @docGroup 3. Caching options
    */
    fetchPolicy?: PreloadQueryFetchPolicy;
    /**
    * If `true`, the query can return partial results from the cache if the cache doesn't contain results for all queried fields.
    * 
    * The default value is `false`.
    * 
    * @docGroup 3. Caching options
    */
    returnPartialData?: boolean;
    /**
    * Specifies whether a `NetworkStatus.refetch` operation should merge
    * incoming field data with existing data, or overwrite the existing data.
    * Overwriting is probably preferable, but merging is currently the default
    * behavior, for backwards compatibility with Apollo Client 3.x.
    * 
    * @docGroup 3. Caching options
    */
    refetchWritePolicy?: RefetchWritePolicy;
    /**
    * Determines whether events trigger refetches for the query. Provide an
    * object mapping each refetch event to `true` (enable), `false` (disable)
    * or a callback function that returns `true`/`false` to control individual
    * events. Provide `false` to disable all automatic refetch events for this
    * query. Provide `true` to enable all automatic refetch events for this query.
    * Provide a callback function to perform additional logic to determine
    * whether to enable or disable a refetch for a query.
    * 
    * `@remarks`
    * `refetchOn` inherits from `defaultOptions.watchQuery.refetchOn`. If
    * `defaultOptions.watchQuery.refetchOn` is not set, all refetch events are
    * enabled by default.
    * 
    * This option only has an effect when the client is configured with a
    * `refetchEventManager`.
    * @docGroup 1. Operation options
    */
    refetchOn?: RefetchOn.Option;
} & VariablesOption<TVariables>;
/**
 * A function that will begin loading a query when called. It's result can be
 * read by `useReadQuery` which will suspend until the query is loaded.
 * This is useful when you want to start loading a query as early as possible
 * outside of a React component.
 *
 * @example
 *
 * ```js
 * const preloadQuery = createQueryPreloader(client);
 * const queryRef = preloadQuery(query, { variables, ...otherOptions });
 *
 * function App() {
 *   return (
 *     <Suspense fallback={<div>Loading</div>}>
 *       <MyQuery />
 *     </Suspense>
 *   );
 * }
 *
 * function MyQuery() {
 *   const { data } = useReadQuery(queryRef);
 *
 *   // do something with `data`
 * }
 * ```
 */
export interface PreloadQueryFunction extends PreloadQueryFunction.Signatures.Evaluated {
    /**
     * A function that returns a promise that resolves when the query has finished
     * loading. The promise resolves with the `QueryReference` itself.
     *
     * @remarks
     * This method is useful for preloading queries in data loading routers, such
     * as [React Router](https://reactrouter.com/en/main) or [TanStack Router](https://tanstack.com/router),
     * to prevent routes from transitioning until the query has finished loading.
     * `data` is not exposed on the promise to discourage using the data in
     * `loader` functions and exposing it to your route components. Instead, we
     * prefer you rely on `useReadQuery` to access the data to ensure your
     * component can rerender with cache updates. If you need to access raw query
     * data, use `client.query()` directly.
     *
     * @example
     * Here's an example using React Router's `loader` function:
     *
     * ```ts
     * import { createQueryPreloader } from "@apollo/client";
     *
     * const preloadQuery = createQueryPreloader(client);
     *
     * export async function loader() {
     *   const queryRef = preloadQuery(GET_DOGS_QUERY);
     *
     *   return preloadQuery.toPromise(queryRef);
     * }
     *
     * export function RouteComponent() {
     *   const queryRef = useLoaderData();
     *   const { data } = useReadQuery(queryRef);
     *
     *   // ...
     * }
     * ```
     */
    toPromise<TQueryRef extends PreloadedQueryRef<any, any, any>>(queryRef: TQueryRef): Promise<TQueryRef>;
}
export declare namespace PreloadQueryFunction {
    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
    }
    namespace DocumentationTypes {
        /**
        * @deprecated Avoid manually specifying generics on `preloadQuery`.
        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
        *
        *
        * A function that will begin loading a query when called. It's result can be
        * read by `useReadQuery` which will suspend until the query is loaded.
        * This is useful when you want to start loading a query as early as possible
        * outside of a React component.
        * 
        * @example
        * 
        * ```js
        * const preloadQuery = createQueryPreloader(client);
        * const queryRef = preloadQuery(query, { variables, ...otherOptions });
        * 
        * function App() {
        *   return (
        *     <Suspense fallback={<div>Loading</div>}>
        *       <MyQuery />
        *     </Suspense>
        *   );
        * }
        * 
        * function MyQuery() {
        *   const { data } = useReadQuery(queryRef);
        * 
        *   // do something with `data`
        * }
        * ```
        */
        interface PreloadQueryFunction_Deprecated extends PreloadQueryFunction {
        }
    }
    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | PreloadQueryOptions<TVariables>> = TOptions extends any ? PreloadedQueryRef<TData, TVariables, ResultForOptions.States<TOptions, DefaultOptions>> : never;
    namespace ResultForOptions {
        type States<TOptions, TDefaultOptions extends DefaultOptions = DefaultOptions> = "complete" | "streaming" | (OptionWithFallback<TOptions, TDefaultOptions, "errorPolicy"> extends ("none") ? never : "empty") | (OptionWithFallback<TOptions, TDefaultOptions, "returnPartialData"> extends false ? never : "partial");
    }
    namespace Signatures {
        interface Classic {
            /**
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
                returnPartialData: true;
                errorPolicy: "ignore" | "all";
            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
            /**
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
                errorPolicy: "ignore" | "all";
            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
            /**
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
                returnPartialData: true;
            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
            /**
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
                options?: PreloadQueryOptions<NoInfer<TVariables>>
            ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
            /**
            * @deprecated Avoid manually specifying generics on `preloadQuery`.
            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
            * 
            * 
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
                returnPartialData: true;
                errorPolicy: "ignore" | "all";
            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
            /**
            * @deprecated Avoid manually specifying generics on `preloadQuery`.
            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
            * 
            * 
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
                errorPolicy: "ignore" | "all";
            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
            /**
            * @deprecated Avoid manually specifying generics on `preloadQuery`.
            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
            * 
            * 
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
                returnPartialData: true;
            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
            /**
            * @deprecated Avoid manually specifying generics on `preloadQuery`.
            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
            * 
            * 
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
                options?: PreloadQueryOptions<NoInfer<TVariables>>
            ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
        }
        /**
        * A function that will begin loading a query when called. It's result can be
        * read by `useReadQuery` which will suspend until the query is loaded.
        * This is useful when you want to start loading a query as early as possible
        * outside of a React component.
        * 
        * @example
        * 
        * ```js
        * const preloadQuery = createQueryPreloader(client);
        * const queryRef = preloadQuery(query, { variables, ...otherOptions });
        * 
        * function App() {
        *   return (
        *     <Suspense fallback={<div>Loading</div>}>
        *       <MyQuery />
        *     </Suspense>
        *   );
        * }
        * 
        * function MyQuery() {
        *   const { data } = useReadQuery(queryRef);
        * 
        *   // do something with `data`
        * }
        * ```
        */
        interface Modern {
            /**
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables, TOptions extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): PreloadQueryFunction.ResultForOptions<TData, TVariables, Record<string, never>>;
            /**
            * A function that will begin loading a query when called. It's result can be
            * read by `useReadQuery` which will suspend until the query is loaded.
            * This is useful when you want to start loading a query as early as possible
            * outside of a React component.
            * 
            * @example
            * 
            * ```js
            * const preloadQuery = createQueryPreloader(client);
            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
            * 
            * function App() {
            *   return (
            *     <Suspense fallback={<div>Loading</div>}>
            *       <MyQuery />
            *     </Suspense>
            *   );
            * }
            * 
            * function MyQuery() {
            *   const { data } = useReadQuery(queryRef);
            * 
            *   // do something with `data`
            * }
            * ```
            */
            <TData, TVariables extends OperationVariables, TOptions extends PreloadQueryOptions<NoInfer<TVariables>> & VariablesOption<TVariables & {
                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions] : [options: TOptions]): PreloadQueryFunction.ResultForOptions<TData, TVariables, TOptions>;
        }
        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
    }
}
/**
 * A higher order function that returns a `preloadQuery` function which
 * can be used to begin loading a query with the given `client`. This is useful
 * when you want to start loading a query as early as possible outside of a
 * React component.
 *
 * > Refer to the [Suspense - Initiating queries outside React](https://www.apollographql.com/docs/react/data/suspense#initiating-queries-outside-react) section for a more in-depth overview.
 *
 * @param client - The `ApolloClient` instance that will be used to load queries
 * from the returned `preloadQuery` function.
 * @returns The `preloadQuery` function.
 *
 * @example
 *
 * ```js
 * const preloadQuery = createQueryPreloader(client);
 * ```
 */
export declare function createQueryPreloader(client: ApolloClient): PreloadQueryFunction;
//# sourceMappingURL=createQueryPreloader.d.ts.map