import type { OverflowMixinInterface } from './mixins/OverflowMixin';
/**
 * Options for finding focusable elements.
 */
type FindFocusableOptions = {
    /** Elements to include (and its subtree) in the search. */
    includeElements?: HTMLElement[];
    /** Elements to exclude (and its subtree) from the search. */
    excludedElements?: HTMLElement[];
    /** Selectors to include in the search. */
    includeSelectors?: string[];
    /** Selectors to exclude from the search. */
    excludeSelectors?: string[];
    /**
     * When true, elements with `tabindex="-1"` and their subtrees are excluded from the search.
     * This supports composite widget patterns (e.g., roving tabindex in lists) where
     * inactive items and their children should not be reachable via Tab navigation.
     */
    stopAtNonTabbable?: boolean;
};
/**
 * nodeB precedes nodeA in either a pre-order depth-first traversal of a tree containing both
 * (e.g., as a descendant or preceding sibling or a descendant of a preceding sibling or
 * preceding sibling of an ancestor) or (if they are disconnected) in an arbitrary but
 * consistent ordering.
 *
 * @param nodeA - The first node to compare.
 * @param nodeB - The second node to compare.
 * @returns - True if nodeA is after nodeB, false otherwise.
 *
 * @see [compareDocumentPosition](https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition)
 */
export declare const isAfter: (nodeA: Element, nodeB: Element) => boolean;
/**
 * nodeB follows nodeA in either a pre-order depth-first traversal of a tree containing both
 * (e.g., as a descendant or following sibling or a descendant of a following sibling or
 * following sibling of an ancestor) or (if they are disconnected) in an arbitrary but
 * consistent ordering.
 *
 * @param nodeA - The first node to compare.
 * @param nodeB - The second node to compare.
 * @returns - True if nodeA is before nodeB, false otherwise.
 *
 * @see [compareDocumentPosition](https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition)
 */
export declare const isBefore: (nodeA: Element, nodeB: Element) => boolean;
/**
 * Checks if the element has no client rectangles (not visible in the viewport).
 *
 * @param element - The element to check.
 * @returns True if the element has no client rectangles.
 */
export declare const hasNoClientRects: (element: HTMLElement) => boolean;
/**
 * Checks if the element has zero dimensions (width and height are both 0).
 *
 * @param element - The element to check.
 * @returns True if the element has zero dimensions.
 */
export declare const hasZeroDimensions: (element: HTMLElement) => boolean;
/**
 * Checks if the element is scrollable (has overflow content).
 *
 * @param element - The element to check.
 * @returns True if the element is scrollable.
 */
export declare const isScrollable: (element: HTMLElement) => boolean;
/**
 * Determines if the element is not visible in the DOM.
 *
 * @param element - The element to check.
 * @returns True if the element is not visible.
 */
export declare const isNotVisible: (element: HTMLElement) => boolean;
/**
 * Checks if the element has inline styles that make it hidden.
 *
 * @param element - The element to check.
 * @returns True if the element has inline styles that make it hidden.
 */
export declare const hasHiddenStyle: (element: HTMLElement) => boolean;
/**
 * Checks if the element is hidden by a computed style.
 *
 * @param element - The element to check.
 * @returns True if the element is hidden by a computed style.
 */
export declare const hasComputedHidden: (element: HTMLElement) => boolean;
/**
 * Checks if the element is hidden from the user.
 *
 * @param element - The element to check.
 * @returns True if the element is hidden.
 */
export declare const isHidden: (element: HTMLElement) => boolean;
/**
 * Checks if the element is disabled.
 *
 * @param element - The element to check.
 * @returns True if the element is disabled.
 */
export declare const isDisabled: (element: any) => any;
/**
 * Checks if the element is not tabbable.
 *
 * @param element - The element to check.
 * @returns True if the element is not tabbable.
 */
export declare const isTabbable: (element: HTMLElement) => boolean;
/**
 * Checks if the element is interactive.
 *
 * @param element - The element to check.
 * @returns True if the element is interactive.
 */
export declare const isInteractiveElement: (element: HTMLElement) => boolean;
/**
 * Checks if the element matches any of the given selectors.
 *
 * @param element - The element to check.
 * @param selectors - The list of selectors to match against.
 * @returns True if the element matches any of the selectors.
 */
export declare const isMatchAny: (element: HTMLElement, selectors: string[]) => boolean;
/**
 * Checks if the element is focusable.
 *
 * @param element - The element to check.
 * @returns True if the element is focusable.
 */
export declare const isFocusable: (element: HTMLElement) => boolean;
/**
 * Recursively finds all focusable elements within the given root and its descendants.
 *
 * Make sure this is performant, as it will be called multiple times.
 *
 * @param root - The root element to search for focusable elements.
 * @param options - Options to customize the search.
 * @returns The list of focusable elements.
 */
export declare const findFocusable: (root: ShadowRoot | HTMLElement | null, options?: FindFocusableOptions) => HTMLElement[];
/**
 * Get the active element from the DOM, including shadow DOMs
 *
 * @param root - The root document or element to start the search from. Defaults to the global document.
 * @returns The active element, or null if there is none.
 */
export declare const getDomActiveElement: (root?: Document | Element) => Element | null;
/**
 * Type guard to check if an element inherits the OverflowMixin.
 *
 * @param element - The element to check
 * @returns True if the element has the OverflowMixin methods
 */
export declare const hasOverflowMixin: <T extends HTMLElement>(element: T) => element is T & OverflowMixinInterface;
/**
 * Recursively gets the host element if the provided element is inside a shadow DOM.
 *
 * @param element - The element to check
 * @returns The host element if inside shadow DOM, otherwise the original element
 */
export declare const getElementOrHost: (element: Element) => Element;
/**
 * Recursively gets all root elements for the provided element, including shadow DOM hosts.
 * First item is the element itself, followed by its shadow host, then the host's shadow host, and so on.
 * The last item is the top-level document.
 *
 * @param element - The element to check
 * @returns An array of elements starting with the original element and followed by its shadow hosts up the tree
 */
export declare const getHostComposePath: (element: Element) => Array<Element>;
export {};
