import { type Event, type Store } from "effector";
import type { ApolloClient, DocumentNode, OperationVariables, StoreObject, TypedDocumentNode } from "@apollo/client";
interface CreateFragmentBindingOptions<Data, Variables> {
    /** Your Apollo Client instance. */
    client: ApolloClient<unknown> | Store<ApolloClient<unknown>>;
    /**
     * A GraphQL Document with a single `fragment` that you're binding.
     */
    document: DocumentNode | TypedDocumentNode<Data, Variables>;
    /**
     * A trigger to setup the binding.
     *
     * When called, will start listening to the Apollo Cache. Usually,
     * this will will be your `appStarted` event.
     */
    setup: Event<unknown>;
    /**
     * A trigger to teardown the binding.
     *
     * Acts as a full `reset` action on binding, stopping listening to
     * Apollo Cache and clearing `$data`.
     *
     * You must then call `setup` again to re-activate the binding.
     */
    teardown?: Event<unknown>;
    /**
     * A map of Variables that your fragment uses.
     * Can be omitted if the fragment uses no variables.
     */
    variables?: Store<Variables>;
    /**
     * Define how to identify a specific fragment.
     *
     * When provided with `Store<string>`, treat this as a ready-to-use
     * canonical Cache ID.
     *
     * When provided with `Store<StoreObject>`, treat this as an object
     * with all required _key fields_. It'll be passed to `cache.identify`.
     */
    id: Store<string> | Store<StoreObject>;
    /** Watch for optimistic updates? */
    optimistic?: boolean;
    /** The name of your binding. Will be derived from the `document` if abscent. */
    name?: string;
}
export interface FragmentBinding<Data, Variables> {
    /**
     * The fragment data. Will be null if entry was not found in cache, or if
     * the binding has not been set up yet.
     */
    $data: Store<Data | null>;
    /**
     * Is this binding active?
     *
     * Only active binding is fully set up, watches cache and keeps `$data` in sync.
     */
    $active: Store<boolean>;
    meta: {
        name: string;
        document: TypedDocumentNode<Data, Variables>;
        client: Store<ApolloClient<unknown>>;
    };
}
/**
 * Allows you to bind a GraphQL fragment to Effector.
 *
 * Creates a live fragment binding to Apollo Cache. When cache updates,
 * so will this binding. This allows you to access on small chunks of
 * cached data.
 *
 * Note: binding _does not_ make a network request. It only binds already
 * existing, cached data so it's accessible from Effector.
 */
export declare function createFragmentBinding<Data, Variables extends OperationVariables = OperationVariables>({ client, document, setup, teardown, id, variables, optimistic, name, }: CreateFragmentBindingOptions<Data, Variables>): FragmentBinding<Data, Variables>;
export {};