import { ControllerBase, type ControllerHost } from './Abstracts/ControllerBase';
/**
 * The callback function for a IntersectionController.
 *
 * @public
 */
export type IntersectionValueCallback<T = unknown> = (...args: Parameters<IntersectionObserverCallback>) => T;
/**
 * The config options for a IntersectionController.
 *
 * @public
 */
export interface IIntersectionControllerConfig<T = unknown> {
    /**
     * Configuration object for the IntersectionObserver.
     */
    config?: IntersectionObserverInit;
    /**
     * The element to observe. In addition to configuring the target here,
     * the `observe` method can be called to observe additional targets. When not
     * specified, the target defaults to the `host`. If set to `null`, no target
     * is automatically observed. Only the configured target will be re-observed
     * if the host connects again after unobserving via disconnection.
     */
    target?: Element | null;
    /**
     * The callback used to process detected changes into a value stored
     * in the controller's `value` property.
     */
    callback?: IntersectionValueCallback<T>;
    /**
     * An IntersectionObserver reports the initial intersection state
     * when observe is called. Setting this flag to true skips processing this
     * initial state for cases when this is unnecessary.
     */
    skipInitial?: boolean;
}
/**
 * IntersectionController is a ReactiveController that integrates an
 * IntersectionObserver with a ReactiveControllerHost's reactive update
 * lifecycle. This is typically a ReactiveElement or LitElement.
 * IntersectionObservers can be used to detect when a target element
 * "intersects" is visible inside of) another element or the viewport by
 * default, where intersect means "visible inside of."
 *
 * The controller can specify a `target` element to observe and the
 * configuration options to pass to the IntersectionObserver. The `observe`
 * method can be called to observe additional elements.
 *
 * When a change is detected, the controller's given `callback` function is
 * used to process the result into a value which is stored on the controller.
 * The controller's `value` is usable during the host's update cycle.
 *
 * @public
 */
export declare class IntersectionController<T = unknown> extends ControllerBase {
    private readonly _targets;
    private readonly _observer;
    private readonly _skipInitial;
    /**
         * Flag used to help manage calling the `callback` when observe is called
         * and `skipInitial` is set to true. Note that unlike the other observers
         * IntersectionObserver *does* report its initial state (e.g. whether or not
         * there is an intersection). This flag is used to avoid handling this
         * state if `skipInitial` is true.
         */
    private _unobservedUpdate;
    constructor(host: ControllerHost, config?: IIntersectionControllerConfig<T>);
    /**
     * The result of processing the observer's changes via the `callback`
     * function.
     */
    value?: T | undefined;
    /**
         * Function that returns a value processed from the observer's changes.
         * The result is stored in the `value` property.
         */
    callback?: IntersectionValueCallback<T> | undefined;
    /**
     * @public
     * @override
     */
    hostConnected(): void;
    /**
     * @public
     * @override
     */
    hostDisconnected(): void;
    /**
     * @public
     * @override
     */
    hostUpdated(): void;
    /**
     * Observe the target element. The controller's `target` is automatically
     * observed when the host connects.
     * @param target Element to observe
     */
    observe(target: Element): void;
    /**
     * Unobserve the target element.
     * @param target Element to unobserve
     */
    unobserve(target: Element): void;
    /**
     * Disconnects the observer. This is done automatically when the host
     * disconnects.
     */
    protected disconnect(): void;
    /**
     * Process the observer's changes with the controller's `callback`
     * function to produce a result stored in the `value` property.
     */
    protected handleChanges(entries: Array<IntersectionObserverEntry>): void;
}
//# sourceMappingURL=IntersectionController.d.ts.map