export function activatePopup(...args: any[]): Popup;
/**
 * @import { PopupPosition } from '../typedefs';
 */
/**
 * Implement the popup handler.
 */
declare class Popup {
    /**
     * Initialize a new `Popup` instance. Note that the `popupElement` is optional, because the
     * element is typically mounted only while the popup is open. Use {@link attachPopupElement} to
     * provide it later.
     * @param {HTMLButtonElement} anchorElement `<button>` element that triggers the popup.
     * @param {HTMLDialogElement | undefined} popupElement `<dialog>` element to be used for the
     * popup, if it’s already in the DOM tree.
     * @param {PopupPosition} position Where to show the popup content.
     * @param {HTMLElement} [positionBaseElement] The base element of the `position`. If omitted, this
     * will be the `anchorElement`.
     */
    constructor(anchorElement: HTMLButtonElement, popupElement: HTMLDialogElement | undefined, position: PopupPosition, positionBaseElement?: HTMLElement);
    /**
     * Open or close the popup, running side effects synchronously.
     * @param {boolean} value `true` to open, `false` to close.
     */
    set open(value: boolean);
    /**
     * Whether the popup is open.
     * @returns {boolean} `true` if the popup is open.
     */
    get open(): boolean;
    style: {
        inset: string | undefined;
        zIndex: number | undefined;
        minWidth: string | undefined;
        maxWidth: string | undefined;
        height: string | undefined;
    };
    /**
     * A reference to the `<dialog>` element used for the popup, which also serves as the backdrop.
     * This is `undefined` while the element is not in the DOM tree, which is the case for a closed
     * popup that doesn’t keep its content.
     * @type {HTMLDialogElement | undefined}
     */
    popupElement: HTMLDialogElement | undefined;
    /**
     * A reference to the element holding the popup content. Unlike {@link popupElement}, which a
     * nested popup shares with its parent, this element belongs to this popup alone, so it’s the one
     * that carries the {@link id} and that the anchor’s `aria-controls` points at.
     * @type {HTMLElement | undefined}
     */
    contentElement: HTMLElement | undefined;
    anchorElement: HTMLButtonElement;
    position: PopupPosition;
    positionBaseElement: HTMLElement;
    id: string;
    intersectionObserver: IntersectionObserver;
    resizeObserver: ResizeObserver;
    _rafId: number;
    viewportResizeObserver: ResizeObserver;
    /**
     * Attach the `<dialog>` element used for the popup. This is called every time the element is
     * mounted, which happens on each open.
     * @param {HTMLDialogElement} popupElement `<dialog>` element to be used for the popup. A nested
     * popup shares this with its parent, so it must not be labelled as belonging to this popup.
     * @param {HTMLElement} [contentElement] Element holding this popup’s content. When omitted, the
     * `popupElement` is assumed to hold the content on its own.
     */
    attachPopupElement(popupElement: HTMLDialogElement, contentElement?: HTMLElement): void;
    /**
     * Detach the `<dialog>` element, typically because it’s being unmounted. The `aria-controls`
     * attribute on the anchor is left to the {@link open} setter, which removes it once the closing
     * animation is complete.
     */
    detachPopupElement(): void;
    /**
     * Whether the anchor element is disabled.
     * @type {boolean}
     */
    get isDisabled(): boolean;
    /**
     * Whether the anchor element is read-only.
     * @type {boolean}
     */
    get isReadOnly(): boolean;
    /**
     * Check the position of the anchor element and, if the popup is mounted, recalculate and apply
     * its inset and size. This is a no-op while the popup element is not in the DOM tree; the caller
     * is expected to call this again once the element is attached.
     *
     * This measures the anchor synchronously with `getBoundingClientRect()` rather than reacting to
     * an `IntersectionObserver`, whose delivery isn’t guaranteed to be timely or frame-aligned the
     * way `ResizeObserver`’s is: a stale computation could arrive after a fresher one and silently
     * overwrite it, occasionally leaving the popup mispositioned after a resize.
     */
    checkPosition(): void;
    /**
     * Hide the popup immediately (when the anchor is being hidden).
     */
    hideImmediately(): Promise<void>;
    /**
     * Dispose of the popup, disconnecting observers and canceling pending work.
     */
    destroy(): void;
    #private;
}
import type { PopupPosition } from '../typedefs';
export {};