import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
import type { DocumentNode } from "graphql";
import type { ApolloClient, DefaultContext, ErrorLike, ErrorPolicy, FetchPolicy, OperationVariables } from "@apollo/client";
import type { MaybeMasked } from "@apollo/client/masking";
import type { NoInfer } from "@apollo/client/utilities";
export declare namespace useSubscription {
    interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
        /**
        * An object containing all of the variables your subscription needs to execute
        */
        variables?: TVariables;
        /**
        * How you want your component to interact with the Apollo cache. For details, see [Setting a fetch policy](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy).
        */
        fetchPolicy?: FetchPolicy;
        /**
        * Specifies the `ErrorPolicy` to be used for this operation
        */
        errorPolicy?: ErrorPolicy;
        /**
        * Determines if your subscription should be unsubscribed and subscribed again when an input to the hook (such as `subscription` or `variables`) changes.
        */
        shouldResubscribe?: boolean | ((options: Options<TData, TVariables>) => boolean);
        /**
        * An `ApolloClient` instance. By default `useSubscription` / `Subscription` uses the client passed down via context, but a different client can be passed in.
        */
        client?: ApolloClient;
        /**
        * Determines if the current subscription should be skipped. Useful if, for example, variables depend on previous queries and are not ready yet.
        */
        skip?: boolean;
        /**
        * Shared context between your component and your network interface (Apollo Link).
        */
        context?: DefaultContext;
        /**
        * Shared context between your component and your network interface (Apollo Link).
        */
        extensions?: Record<string, any>;
        /**
        * Allows the registration of a callback function that will be triggered each time the `useSubscription` Hook / `Subscription` component completes the subscription.
        * 
        * @since
        * 
        * 3.7.0
        */
        onComplete?: () => void;
        /**
        * Allows the registration of a callback function that will be triggered each time the `useSubscription` Hook / `Subscription` component receives data. The callback `options` object param consists of the current Apollo Client instance in `client`, and the received subscription data in `data`.
        * 
        * @since
        * 
        * 3.7.0
        */
        onData?: (options: OnDataOptions<TData>) => any;
        /**
        * Allows the registration of a callback function that will be triggered each time the `useSubscription` Hook / `Subscription` component receives an error.
        * 
        * @since
        * 
        * 3.7.0
        */
        onError?: (error: ErrorLike) => void;
        /**
        * If `true`, the hook will not cause the component to rerender. This is useful when you want to control the rendering of your component yourself with logic in the `onData` and `onError` callbacks.
        * 
        * Changing this to `true` when the hook already has `data` will reset the `data` to `undefined`.
        * 
        * @defaultValue `false`
        */
        ignoreResults?: boolean;
    }
    interface Result<TData = unknown> {
        /**
        * A boolean that indicates whether any initial data has been returned
        */
        loading: boolean;
        /**
        * An object containing the result of your GraphQL subscription. Defaults to an empty object.
        */
        data?: MaybeMasked<TData>;
        /**
        * A runtime error with `graphQLErrors` and `networkError` properties
        */
        error?: ErrorLike;
        restart: () => void;
    }
    type OnDataResult<TData = unknown> = Omit<Result<TData>, "restart">;
    interface OnDataOptions<TData = unknown> {
        client: ApolloClient;
        data: OnDataResult<TData>;
    }
    interface OnSubscriptionDataOptions<TData = unknown> {
        client: ApolloClient;
        subscriptionData: OnDataResult<TData>;
    }
}
/**
 * > Refer to the [Subscriptions](https://www.apollographql.com/docs/react/data/subscriptions/) section for a more in-depth overview of `useSubscription`.
 *
 * @example
 * ```jsx
 * const COMMENTS_SUBSCRIPTION = gql`
 *   subscription OnCommentAdded($repoFullName: String!) {
 *     commentAdded(repoFullName: $repoFullName) {
 *       id
 *       content
 *     }
 *   }
 * `;
 *
 * function DontReadTheComments({ repoFullName }) {
 *   const {
 *     data: { commentAdded },
 *     loading,
 *   } = useSubscription(COMMENTS_SUBSCRIPTION, { variables: { repoFullName } });
 *   return <h4>New comment: {!loading && commentAdded.content}</h4>;
 * }
 * ```
 * @remarks
 * #### Consider using `onData` instead of `useEffect`
 *
 * If you want to react to incoming data, please use the `onData` option instead of `useEffect`.
 * State updates you make inside a `useEffect` hook might cause additional rerenders, and `useEffect` is mostly meant for side effects of rendering, not as an event handler.
 * State updates made in an event handler like `onData` might - depending on the React version - be batched and cause only a single rerender.
 *
 * Consider the following component:
 *
 * ```jsx
 * export function Subscriptions() {
 *   const { data, error, loading } = useSubscription(query);
 *   const [accumulatedData, setAccumulatedData] = useState([]);
 *
 *   useEffect(() => {
 *     setAccumulatedData((prev) => [...prev, data]);
 *   }, [data]);
 *
 *   return (
 *     <>
 *       {loading && <p>Loading...</p>}
 *       {JSON.stringify(accumulatedData, undefined, 2)}
 *     </>
 *   );
 * }
 * ```
 *
 * Instead of using `useEffect` here, we can re-write this component to use the `onData` callback function accepted in `useSubscription`'s `options` object:
 *
 * ```jsx
 * export function Subscriptions() {
 *   const [accumulatedData, setAccumulatedData] = useState([]);
 *   const { data, error, loading } = useSubscription(
 *     query,
 *     {
 *       onData({ data }) {
 *         setAccumulatedData((prev) => [...prev, data])
 *       }
 *     }
 *   );
 *
 *   return (
 *     <>
 *       {loading && <p>Loading...</p>}
 *       {JSON.stringify(accumulatedData, undefined, 2)}
 *     </>
 *   );
 * }
 * ```
 *
 * > ⚠️ **Note:** The `useSubscription` option `onData` is available in Apollo Client >= 3.7. In previous versions, the equivalent option is named `onSubscriptionData`.
 *
 * Now, the first message will be added to the `accumulatedData` array since `onData` is called _before_ the component re-renders. React 18 automatic batching is still in effect and results in a single re-render, but with `onData` we can guarantee each message received after the component mounts is added to `accumulatedData`.
 *
 * @since 3.0.0
 * @param subscription - A GraphQL subscription document parsed into an AST by `gql`.
 * @param options - Options to control how the subscription is executed.
 * @returns Query result object
 */
export declare function useSubscription<TData = unknown, TVariables extends OperationVariables = OperationVariables>(subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useSubscription.Options<NoInfer<TData>, NoInfer<TVariables>>): useSubscription.Result<TData>;
//# sourceMappingURL=useSubscription.d.ts.map
