interface BlockBodyScrollOptions {
    className?: string;
    variableName?: string;
}
/**
 * Blocks page scrolling by adding an overflow-hiding class to `document.body`. Pair with
 * `unblockBodyScroll` using the same class name.
 *
 * The class itself is supplied by the consuming stylesheet; this only applies it. Nested calls are
 * not reference-counted, so the first `unblockBodyScroll` restores scrolling for all callers.
 *
 * @param option Class name as a string, or `{ className, variableName }` where `variableName` is a custom property set on the body to the current scrollbar width — used to pad away the layout shift.
 *
 * @example
 * ```ts
 * blockBodyScroll({ className: 'p-overflow-hidden', variableName: '--scrollbar-width' });
 * ```
 */
declare function blockBodyScroll(option?: string | BlockBodyScrollOptions): void;

/**
 * Downloads `csv` as a UTF-8 `.csv` file via a temporary object URL, revoked after 40 seconds. Falls
 * back to the legacy `msSaveOrOpenBlob` API where present, and to opening a `data:` URL in a new
 * window when the anchor `download` attribute is unsupported — that last path is subject to popup
 * blocking and URL length limits.
 *
 * Emits the string as given: no BOM is prepended, and no escaping or injection guarding is applied to
 * the cell contents.
 *
 * @param csv CSV text.
 * @param filename File name without the `.csv` extension, which is appended.
 */
declare function exportCSV(csv: string, filename: string): void;

/**
 * Triggers a file download by clicking a temporary anchor, which is appended to `document.body` and
 * removed again before returning. Must be called from a user gesture, or the browser will block the
 * download.
 *
 * @param file Download descriptor. `src` is any URL the anchor accepts — an object URL, a `data:` URL, or a remote address; `name` is the suggested filename.
 * @returns True when the download was triggered; false when no file is given or the browser does not support the `download` attribute. Cross-origin `src` values ignore `name` and may open rather than download.
 *
 * @example
 * ```ts
 * const url = URL.createObjectURL(blob);
 *
 * saveAs({ name: 'export.csv', src: url });
 * URL.revokeObjectURL(url);
 * ```
 */
declare function saveAs(file: {
    name: string;
    src: string;
}): boolean;

interface UnblockBodyScrollOptions {
    className?: string;
    variableName?: string;
}
/**
 * Reverts `blockBodyScroll` by removing the scroll-lock class from `document.body`, and the scrollbar
 * width custom property when one was set.
 *
 * Removal is unconditional rather than reference-counted, so with overlapping overlays the first call
 * unlocks scrolling for all of them.
 *
 * @param option Class name as a string, or an options object. Defaults to the `p-overflow-hidden` class. Pass the same `variableName` given to `blockBodyScroll` to clear it.
 */
declare function unblockBodyScroll(option?: string | UnblockBodyScrollOptions): void;

/**
 * Positions `element` against `target` in document coordinates, flipping above the target when there
 * is not enough room below and clamping horizontally to the viewport. Writes `top`, the inline-start
 * (or inline-end under RTL) offset and `transform-origin` as inline styles; the element must already
 * be absolutely positioned in a document-level stacking context.
 *
 * @param element Element to position. Hidden elements are measured via a temporary reflow.
 * @param target Element to anchor against.
 * @param gutter Apply the `--*-anchor-gutter` CSS variable as a margin between the two, negated when flipped. Defaults to `true`.
 */
declare function absolutePosition(element: HTMLElement, target: HTMLElement | SVGElement, gutter?: boolean): void;

/**
 * Adds one or more classes to `element`. Accepts a space-separated string or an array; nullish
 * entries are skipped. No-ops when either argument is falsy.
 *
 * @param element Target element.
 * @param className Class name, space-separated list, or array of either.
 *
 * @example
 * ```ts
 * addClass(el, 'p-button p-button-sm');
 * addClass(el, ['p-button', isText && 'p-button-text']);
 * ```
 */
declare function addClass(element: Element, className: string | undefined | null | (string | undefined | null)[]): void;

/**
 * Applies inline styles to `element` through the CSP-safe path in `applyStyle`, which drops
 * declarations with unsafe values (e.g. `url()` payloads) instead of writing them.
 *
 * A string replaces any existing `cssText`; an object is merged onto the current inline styles.
 * Object keys may be camelCase or custom properties (`--x`), and a trailing `!important` in either
 * form is honored.
 *
 * @param element Target element. No-ops when falsy.
 * @param style CSS text (`'color:red;width:2rem'`) or a property map.
 */
declare function addStyle(element: HTMLElement, style: string | object): void;

/**
 * Positions an overlay against its target, choosing the strategy that matches where the overlay was
 * mounted: `relativePosition` when it stays inside the target's parent, `absolutePosition` otherwise.
 *
 * @param overlay Overlay element to position.
 * @param target Element the overlay is anchored to.
 * @param appendTo Mount location the overlay was rendered into; `'self'` selects relative positioning.
 * @param calculateMinWidth Match the overlay's `min-width` to the target's outer width. Ignored when `appendTo` is `'self'`. Defaults to `true`.
 */
declare function alignOverlay(overlay: HTMLElement, target: HTMLElement, appendTo: string, calculateMinWidth?: boolean): void;

/**
 * Appends `child` to a target resolved by `getTargetElement`, so `element` may be a node, a CSS
 * selector, a keyword such as `'body'` or `'@parent'`, or a function returning one.
 *
 * @param element Target descriptor, resolved relative to `child` for the `@`-prefixed keywords.
 * @param child Node to append.
 * @throws When the descriptor resolves to nothing appendable.
 */
declare function appendChild(element: unknown, child: Node | Element): void;

/**
 * Binds `listener` as the sole handler for `eventName` on `element`, removing any previously applied
 * handler for that event. Re-applying the same function reference is a no-op, so this is safe to call
 * on every render.
 *
 * Bookkeeping is stored on the element under `_pListeners`; listeners attached with
 * `addEventListener` directly are not tracked and therefore not removed.
 *
 * @param element Target element.
 * @param eventName Event type, without the `on` prefix.
 * @param listener Handler function or `EventListenerObject`. Other values are ignored.
 */
declare function applyEventListener(element: HTMLElement, eventName: string, listener: unknown): void;

type StyleApplyOptions = {
    clear?: boolean;
};
/**
 * Writes pre-split CSS declarations to `element` via `setProperty`, skipping any whose value fails
 * the `hasUnsafeCssValue` check. Avoids assigning to `cssText` so a hostile value cannot inject
 * additional declarations.
 *
 * Malformed entries (no `:`, empty property) are silently dropped; a trailing `!important` is lifted
 * into the priority argument.
 *
 * @param element Target element.
 * @param declarations Declaration strings, each `property: value`, without separating semicolons.
 * @param options `clear` empties existing inline styles before applying.
 */
declare function applyStyleDeclarationsSafely(element: HTMLElement, declarations: string[], options?: StyleApplyOptions): void;
/**
 * Applies inline styles from CSS text or a property map, filtering unsafe values as
 * `applyStyleDeclarationsSafely` does.
 *
 * String input is split on top-level semicolons only — semicolons inside quotes or parentheses (e.g.
 * a `data:` URI in `url()`) do not terminate a declaration. Object keys are converted from camelCase
 * to kebab-case, except custom properties, which are passed through as-is; `null`/`undefined` values
 * are skipped.
 *
 * @param element Target element.
 * @param style CSS text or a property map.
 * @param options `clear` empties existing inline styles before applying.
 */
declare function applyInlineStyleSafely(element: HTMLElement, style: string | Record<string, unknown>, options?: StyleApplyOptions): void;
declare const _default$1: {
    applyInlineStyleSafely: typeof applyInlineStyleSafely;
    applyStyleDeclarationsSafely: typeof applyStyleDeclarationsSafely;
};

/**
 * Returns the width in pixels currently occupied by the document's vertical scrollbar, as the
 * difference between the window's inner width and the document element's offset width. Returns `0`
 * on overlay-scrollbar platforms and when the page does not scroll.
 *
 * Used to compensate for the layout shift when body scrolling is blocked.
 */
declare function calculateBodyScrollbarWidth(): number;

/**
 * Returns the horizontal scrollbar height in pixels.
 *
 * With `element`, measures that element's own scrollbar from its box metrics. Without one, measures
 * the platform default by mounting a probe on `document.body` and caches the result for the lifetime
 * of the module — a later change in scrollbar styling is not picked up.
 *
 * @param element Element to measure. Omit for the platform-wide default.
 */
declare function calculateScrollbarHeight(element?: HTMLElement): number;

/**
 * Returns the vertical scrollbar width in pixels.
 *
 * With `element`, measures that element's own scrollbar from its box metrics. Without one, measures
 * the platform default by mounting a probe on `document.body` and caches the result for the lifetime
 * of the module — a later change in scrollbar styling is not picked up.
 *
 * @param element Element to measure. Omit for the platform-wide default.
 */
declare function calculateScrollbarWidth(element?: HTMLElement): number;

/**
 * Clears the current text selection, preferring the legacy `Selection.empty()` where available and
 * falling back to `removeAllRanges()`. The fallback runs only when the first range has client rects,
 * leaving collapsed or non-rendered selections untouched.
 */
declare function clearSelection(): void;

/**
 * Creates a detached element, applies `attributes` through `setAttributes`, and appends `children`.
 * String children are appended as text nodes, never parsed as markup.
 *
 * @param type Tag name. Returns `undefined` when empty.
 * @param attributes Attribute map. Supports the `setAttributes` conventions: `on*` keys bind listeners, `style` and `class` accept objects and arrays, and unsafe URL/HTML attribute values are rejected.
 * @param children Text or nodes to append.
 * @returns The new element, or `undefined` when `type` is falsy.
 *
 * @example
 * ```ts
 * const el = createElement('div', { class: ['p-panel', { 'p-panel-toggleable': true }] }, 'Title');
 * ```
 */
declare function createElement(type: string, attributes?: Record<string, unknown>, ...children: (string | Node)[]): HTMLElement | undefined;

/**
 * Builds a `<style>` tag as markup.
 *
 * @deprecated Use `createStyleMarkup` instead.
 */
declare function createStyleAsString(css?: string, options?: Record<string, unknown>): string;

/**
 * Creates a `<style>` element holding `css` as a text node and optionally mounts it. The element is
 * left detached — and therefore inert — when no container is given.
 *
 * @param css Stylesheet text.
 * @param attributes Attributes to set, e.g. `{ nonce, 'data-primevue-style-id': 'button' }`.
 * @param container Node to append the element to.
 * @returns The style element.
 */
declare function createStyleElement(css: string, attributes?: Record<string, unknown>, container?: Element): HTMLStyleElement;

/**
 * Serializes a `<style>` tag for SSR output. Attribute values are escaped via `escapeAttribute`;
 * `css` is emitted verbatim, so it must come from a trusted source — a `</style>` sequence inside it
 * closes the tag early.
 *
 * @param css Stylesheet text. Returns an empty string when falsy.
 * @param attributes Attributes to serialize onto the tag.
 * @returns The markup, or `''`.
 */
declare function createStyleMarkup(css?: string, attributes?: Record<string, unknown>): string;

/**
 * Creates an empty `<style>` element, appended to `document.head` when no container is given.
 *
 * @deprecated Use `createStyleElement` instead.
 */
declare function createStyleTag(attributes?: Record<string, unknown>, container?: Element): HTMLStyleElement;

/**
 * HTML-escapes a value for safe interpolation into a double-quoted HTML attribute (e.g. an emitted
 * `<style nonce="…">` tag). Prevents a `"` (or `&`/`<`/`>`) in the value from breaking out of the
 * attribute context and injecting markup — the attribute-injection XSS sink.
 */
declare function escapeAttribute(value: unknown): string;

/**
 * Fades `element` in over `duration` ms.
 *
 * @returns A cancel function that stops the in-flight animation. Call it when the element unmounts
 *   mid-fade so the scheduling loop doesn't keep running and pin the detached node.
 */
declare function fadeIn(element: HTMLElement, duration: number): () => void;

/**
 * Fades `element` out over `duration` ms.
 *
 * @returns A cancel function that clears the interval. Call it when the element unmounts mid-fade
 *   so the interval doesn't keep running against a detached node.
 */
declare function fadeOut(element: HTMLElement, duration: number): () => void;

/**
 * Returns descendants of `element` matching `selector` as a static array. Returns `[]` when
 * `element` is not an element, so a missing container needs no guard at the call site.
 *
 * @param element Root to search within. It is not itself tested against the selector.
 * @param selector CSS selector.
 * @returns Matching descendants in document order.
 */
declare function find<T extends Element = HTMLElement>(element: Element, selector: string): T[];

/**
 * Returns the first match for `selector`, testing `element` itself before its descendants. Returns
 * `null` when `element` is not an element or nothing matches.
 *
 * @param element Element to test and search within.
 * @param selector CSS selector.
 * @returns `element` when it matches, otherwise its first matching descendant, otherwise `null`.
 */
declare function findSingle<T extends Element = HTMLElement>(element: Element, selector: string): T | null;

/**
 * Focuses `element` unless it already holds focus, avoiding the redundant `focus` event and scroll
 * adjustment a repeat call would cause. No-ops when `element` is falsy.
 *
 * @param element Element to focus.
 * @param options Standard `FocusOptions`, e.g. `{ preventScroll: true }`.
 */
declare function focus(element: HTMLElement, options?: FocusOptions): void;

/**
 * Reads an attribute and coerces it to a number when numeric, or a boolean for exactly `'true'` and
 * `'false'`; every other value is returned as the raw string.
 *
 * @param element Element to read from.
 * @param name Attribute name.
 * @returns The coerced value, `null` when the attribute is absent, or `undefined` when `element` is not an element.
 *
 * @example
 * ```ts
 * getAttribute(el, 'tabindex'); // -1  (number)
 * getAttribute(el, 'aria-hidden'); // true (boolean)
 * getAttribute(el, 'id'); // 'pv_id_1' (string)
 * ```
 */
declare function getAttribute(element: Element, name: string): string | number | boolean | null | undefined;

type BrowserType = {
    version?: string;
    chrome?: boolean;
    webkit?: boolean;
    safari?: boolean;
    opera?: boolean;
    msie?: boolean;
    mozilla?: boolean;
    [key: string]: string | boolean | undefined;
};
/**
 * Returns a user-agent-derived browser descriptor: a `version` string plus a `true` flag for the
 * matched engine/vendor (`chrome`, `webkit`, `safari`, `opera`, `msie`, `mozilla`). Chrome also sets
 * `webkit`, and a `webkit` match that is not Chrome also sets `safari`.
 *
 * Computed once and cached for the lifetime of the module. User-agent sniffing is unreliable — prefer
 * feature detection where possible.
 */
declare function getBrowser(): BrowserType;

/**
 * Returns the user's preferred language tag from `navigator.languages`, falling back to
 * `navigator.language` and then to `'en'`.
 */
declare function getBrowserLanguage(): string;

/**
 * Reads a CSS property or custom property from an element.
 *
 * The computed lookup returns the raw declaration text for custom properties — `var()` chains,
 * `light-dark()` and `color-mix()` come back unresolved. Use `resolveCSSColor` when the final color
 * value is needed.
 *
 * @param element Element to read from.
 * @param property Property name, e.g. `'width'` or `'--p-primary-color'`.
 * @param inline Read only the element's inline style declaration instead of the computed style.
 * @returns The value, `''` when unset, or `null` when either argument is missing.
 */
declare function getCSSProperty(element?: HTMLElement, property?: string, inline?: boolean): string | null;

/**
 * Scans every reachable stylesheet rule for the first custom property whose name matches
 * `variableRegex` and returns its declared name and value.
 *
 * Reads declarations rather than computed styles, so the value is the authored text with `var()`
 * chains unresolved. Cross-origin stylesheets throw on access and are skipped. Cost is proportional
 * to the total number of declared properties in the document — cache the result rather than calling
 * this per frame.
 *
 * @param variableRegex Pattern tested against property names, e.g. `/-anchor-gutter$/`. A global-flag regex is reset before each test.
 * @returns The match, or `null` when nothing matches or the DOM is unavailable.
 */
declare function getCSSVariableByRegex(variableRegex: RegExp): {
    name: string | undefined;
    value: string | undefined;
} | null;

/**
 * Computes where a caret sits inside a text field, for anchoring overlays such as a mention popup.
 *
 * Works by mirroring the field's typography and box metrics onto an off-screen div, wrapping
 * `currentText` in a span, and measuring that span. Requires a rendered element in the main document,
 * since the copied metrics come from `getComputedStyle`.
 *
 * @param element Field to measure against; its scroll offsets are subtracted from the result.
 * @param prevText Text before the caret. Newlines are preserved as `<br>`; inserted as text nodes, never markup.
 * @param nextText Text after the caret.
 * @param currentText Text at the caret whose box is measured.
 * @returns Offsets in pixels relative to the field, `top` being the bottom edge of the measured line. Falls back to `{ top: 'auto', left: 'auto' }` when `element` is falsy.
 */
declare function getCursorOffset(element: Element, prevText: string, nextText: string, currentText: string): {
    top: number | string;
    left: number | string;
};

/**
 * Returns the first focusable descendant of `element` in document order, or `null` when there is
 * none. Focus-trap entry point.
 *
 * @param element Container to search within.
 * @param selector Extra CSS constraint appended to each focusable selector, e.g. `':not(.p-disabled)'`.
 */
declare function getFirstFocusableElement(element: Element, selector?: string): Element | null;

/**
 * Returns focusable descendants of `element` in document order — buttons, links, form controls,
 * `[tabindex]` and `[contenteditable]` — excluding disabled, hidden and `tabindex="-1"` nodes, then
 * filtering out anything computing to `display: none` or `visibility: hidden`.
 *
 * Ordering is document order, not tab order: positive `tabindex` values are not honored. The
 * computed-style pass forces layout, so results are best cached per interaction rather than per frame.
 *
 * @param element Container to search within.
 * @param selector Extra CSS constraint appended to each selector in the list, e.g. `':not(.p-disabled)'`.
 */
declare function getFocusableElements<T extends Element = HTMLElement>(element: Element, selector?: string): T[];

/**
 * Returns the content height in pixels — `offsetHeight` less vertical padding and borders. Returns
 * `0` when `element` is falsy.
 *
 * Reads computed styles, so `element` must be rendered in the main document.
 */
declare function getHeight(element: HTMLElement): number;

/**
 * Measures an element that is hidden via `display: none`, by temporarily forcing
 * `visibility: hidden; display: block` and restoring the previous inline values afterwards.
 *
 * Mutates inline styles for the duration of the call and forces a synchronous layout. The measured
 * box is the one the element has while forced to `display: block`, which may differ from its real
 * layout once shown.
 *
 * @param element Element to measure.
 * @returns Width and height in pixels; `{ width: 0, height: 0 }` when `element` is falsy.
 */
declare function getHiddenElementDimensions(element?: HTMLElement): {
    width: number;
    height: number;
};

/**
 * Returns the `offsetHeight` of an element hidden via `display: none`, by temporarily forcing
 * `visibility: hidden; display: block` and restoring the previous inline values afterwards.
 *
 * Mutates inline styles for the duration of the call and forces a synchronous layout. Returns `0`
 * when `element` is falsy.
 */
declare function getHiddenElementOuterHeight(element: HTMLElement): number;

/**
 * Returns the `offsetWidth` of an element hidden via `display: none`, by temporarily forcing
 * `visibility: hidden; display: block` and restoring the previous inline values afterwards.
 *
 * Mutates inline styles for the duration of the call and forces a synchronous layout. Returns `0`
 * when `element` is falsy.
 */
declare function getHiddenElementOuterWidth(element: HTMLElement): number;

/**
 * Returns the element's position among its parent's element children, ignoring text and comment
 * nodes. Resolves through a shadow root to its host, as `getParentNode` does.
 *
 * @returns The zero-based index, or `-1` when `element` is falsy or detached.
 */
declare function getIndex(element: HTMLElement): number;

/**
 * Returns `offsetWidth` less the horizontal borders — the padding-box width. Returns `0` when
 * `element` is falsy.
 *
 * Reads computed styles, so `element` must be rendered in the main document.
 */
declare function getInnerWidth(element: HTMLElement): number;

/**
 * Returns the last focusable descendant of `element` in document order, or `null` when there is
 * none. Focus-trap wrap-around point.
 *
 * @param element Container to search within.
 * @param selector Extra CSS constraint appended to each focusable selector, e.g. `':not(.p-disabled)'`.
 */
declare function getLastFocusableElement(element: Element, selector?: string): Element | null;

/**
 * Walks forward through following siblings and returns the first one matching `selector`, or `null`
 * when none matches. Does not descend into children.
 *
 * @param element Element to start from; it is not itself tested.
 * @param selector CSS selector.
 */
declare function getNextElementSibling(element: Element, selector: string): Element | null;

/**
 * Returns the focusable element following `element` within `container`. Does not wrap: `null` is
 * returned at the end of the list, and also when `element` is not itself focusable within the
 * container.
 *
 * @param container Container whose focusable elements form the sequence.
 * @param element Current element in that sequence.
 * @param selector Extra CSS constraint appended to each focusable selector.
 */
declare function getNextFocusableElement(container: Element, element: Element, selector?: string): Element | null;

/**
 * Returns the element's position in document coordinates — its viewport rect plus the current window
 * scroll — so the value stays stable as the page scrolls.
 *
 * @param element Element to measure.
 * @returns Offsets in pixels, or `{ top: 'auto', left: 'auto' }` when `element` is nullish.
 */
declare function getOffset(element?: Element | null): {
    top: number | string;
    left: number | string;
};

/**
 * Returns the border-box height in pixels (`offsetHeight`). Returns `0` when `element` is falsy.
 *
 * @param element Element to measure.
 * @param margin Also add the vertical margins, read from computed styles.
 */
declare function getOuterHeight(element: HTMLElement, margin?: boolean): number;

/**
 * Returns the border-box width in pixels (`offsetWidth`). Returns `0` for anything that is not an
 * `HTMLElement` of the main document, including elements from another document or realm.
 *
 * @param element Element to measure.
 * @param margin Also add the horizontal margins, read from computed styles.
 */
declare function getOuterWidth(element: unknown, margin?: boolean): number;

/**
 * Returns the node's parent, crossing shadow boundaries: a `ShadowRoot` parent is reported as its
 * host, so traversal continues into the light DOM instead of stopping at the root.
 *
 * @returns The parent node, or `null` when `element` is falsy or has none.
 */
declare function getParentNode(element: Node): ParentNode | null;

/**
 * Collects the node's ancestors from nearest outward, up to and including `document`. Crosses shadow
 * boundaries via `getParentNode`, so hosts appear in the chain.
 *
 * @param element Node to start from; it is not included in the result.
 * @param parents Accumulator for the recursive walk; prefills the head of the returned list.
 * @returns Ancestors ordered nearest-first.
 */
declare function getParents(element: Node, parents?: ParentNode[]): ParentNode[];

/**
 * Walks backward through preceding siblings and returns the first one matching `selector`, or `null`
 * when none matches. Does not descend into children.
 *
 * @param element Element to start from; it is not itself tested.
 * @param selector CSS selector.
 */
declare function getPreviousElementSibling(element: Element, selector: string): Element | null;

/**
 * Returns the element's horizontal scroll offset as a magnitude, normalizing the negative
 * `scrollLeft` browsers report under RTL. Returns `0` when `element` is omitted.
 */
declare function getScrollLeft(element?: HTMLElement): number;

/**
 * Returns the ancestors that scroll `element` — those whose computed `overflow`, `overflow-x` or
 * `overflow-y` is `auto` or `scroll` — ordered nearest-first. Typically used to attach scroll
 * listeners that reposition an overlay.
 *
 * An ancestor carrying `data-scrollselectors` also contributes its own matching descendants, letting
 * a component nominate an inner scroll container. The document node is excluded; use
 * `window`/`getWindowScrollTop` for page scrolling. Returns `[]` when `element` is falsy.
 */
declare function getScrollableParents(element: Element): Element[];

/**
 * Returns the currently selected text, or `''` when nothing is selected. Returns `undefined` when
 * neither `window.getSelection` nor `document.getSelection` exists.
 */
declare function getSelection(): string | undefined;

/**
 * Resolves a target descriptor to a live node. Accepts the keywords `'document'`, `'window'` and
 * `'body'`; the `@`-relative forms `'@next'`, `'@prev'`, `'@first'`, `'@last'`, `'@child'`,
 * `'@child[n]'`, `'@parent'` and `'@grandparent'`, resolved against `currentElement`; any other
 * string as a CSS selector queried on `document`; a function returning any of the above; or a node,
 * component instance or ref, unwrapped by `toElement`.
 *
 * Resolved nodes must be attached to the document — a detached element yields `undefined`.
 *
 * @param target Descriptor to resolve. Falsy values yield `undefined`.
 * @param currentElement Reference element for the `@`-relative keywords.
 * @returns The resolved node, `null` when a selector or indexed child matches nothing, or `undefined` when the descriptor resolves to nothing usable.
 *
 * @example
 * ```ts
 * getTargetElement('body');
 * getTargetElement('@parent', el);
 * getTargetElement('@child[2]', el);
 * getTargetElement(() => overlayRef.current);
 * ```
 */
declare function getTargetElement(target: unknown, currentElement?: Element): Window | Document | Element | null | undefined;

/**
 * Returns `navigator.userAgent`. Throws in non-browser environments where `navigator` is undefined.
 */
declare function getUserAgent(): string;

/**
 * Returns the viewport size in pixels, preferring `window.innerWidth`/`innerHeight` and falling back
 * to the document element's and body's client dimensions.
 *
 * The primary values include the scrollbars; the fallbacks do not.
 */
declare function getViewport(): {
    width: number;
    height: number;
};

/**
 * Returns the content width in pixels — `offsetWidth` less horizontal padding and borders. Returns
 * `0` when `element` is falsy.
 *
 * Reads computed styles, so `element` must be rendered in the main document.
 */
declare function getWidth(element: HTMLElement): number;

/**
 * Returns the document's horizontal scroll offset in pixels, adjusted by the document element's
 * left border so the value lines up with `getBoundingClientRect` coordinates.
 */
declare function getWindowScrollLeft(): number;

/**
 * Returns the document's vertical scroll offset in pixels, adjusted by the document element's top
 * border so the value lines up with `getBoundingClientRect` coordinates.
 */
declare function getWindowScrollTop(): number;

/**
 * Returns true when the element has a running animation, determined from its computed
 * `animation-duration`. Resolves against the main document, so cross-document (iframe) elements are
 * not supported.
 *
 * @param element Element to inspect.
 * @returns True when the computed animation duration is greater than zero; false for a missing element.
 */
declare function hasCSSAnimation(element: Element): boolean;

/**
 * Returns true when the element has a transition, determined from its computed
 * `transition-duration`. Resolves against the main document, so cross-document (iframe) elements are
 * not supported.
 *
 * @param element Element to inspect.
 * @returns True when the computed transition duration is greater than zero; false for a missing element.
 */
declare function hasCSSTransition(element: Element): boolean;

/**
 * Returns true when the element carries the given class. Falls back to a regex over `className` on
 * elements without `classList` (legacy SVG).
 *
 * @param element Element to inspect.
 * @param className Single class name, without a leading dot.
 * @returns True when the class is present; false for a missing element.
 */
declare function hasClass(element: Element, className: string): boolean;

/**
 * Calls a method on an element, bound to that element. Silently does nothing when the named member
 * is not a function.
 *
 * @param element Element to call the method on.
 * @param methodName Name of an `Element` member.
 * @param args Arguments forwarded to the method.
 *
 * @example
 * ```ts
 * invokeElementMethod(el, 'scrollIntoView', [{ block: 'nearest' }]);
 * ```
 */
declare function invokeElementMethod<T extends keyof Element>(element: Element, methodName: T, args?: unknown[]): void;

/**
 * Returns true when the user agent string identifies Android. Throws on the server, where `navigator`
 * is undefined — guard with `isClient()`.
 */
declare function isAndroid(): boolean;

/**
 * Returns true when an attribute strictly equals the given value. The attribute is read through
 * `getAttribute`, which coerces numeric strings to numbers and `'true'`/`'false'` to booleans, so
 * compare against the coerced type rather than the raw string.
 *
 * @param element Element to inspect.
 * @param name Attribute name.
 * @param value Value to compare against.
 * @returns True on a strict match; false when the element is not an `Element`.
 *
 * @example
 * ```ts
 * // <div data-index="2" data-open="true">
 * isAttributeEquals(el, 'data-index', 2); // true, not '2'
 * isAttributeEquals(el, 'data-open', true); // true, not 'true'
 * ```
 */
declare function isAttributeEquals(element: Element, name: string, value: unknown): boolean;

/**
 * Negation of `isAttributeEquals`. Returns true for a non-`Element` input, since no match is possible.
 *
 * @param element Element to inspect.
 * @param name Attribute name.
 * @param value Value to compare against.
 * @returns True when the attribute does not strictly equal the value.
 */
declare function isAttributeNotEquals(element: Element, name: string, value: unknown): boolean;

/**
 * Returns true when the element is an interactive control, or sits inside one. Matches `INPUT`,
 * `TEXTAREA`, `BUTTON` and `A` on the element or its immediate parent, and any ancestor matching
 * `.p-button`, `.p-checkbox` or `.p-radiobutton`. Used to suppress component-level click handling
 * that would otherwise double-fire on a nested control.
 *
 * @param element Element to inspect.
 * @returns True when a click on the element should be treated as a control interaction; false for a missing element.
 */
declare function isClickable(element: Element): boolean;

/**
 * Returns true when running in a browser with a usable `document`. Use as the SSR guard before
 * touching DOM globals.
 */
declare function isClient(): boolean;

/**
 * Checks if a given CSS property-value pair is supported by the browser.
 *
 * @param property CSS property string
 * @param value CSS value string
 * @returns True if supported, false otherwise
 */
declare function isCssSupported(property: keyof CSSStyleDeclaration | string, value: string): boolean;
/**
 * Checks if a given CSS condition is supported by the browser.
 *
 * @param condition CSS condition string
 * @returns True if supported, false otherwise
 */
declare function isCssSupported(condition: string): boolean;
/**
 * Checks if a given CSS property-value pair or condition is supported by the browser.
 *
 * @param input CSS property or condition
 * @param value CSS value (optional)
 * @returns True if supported, false otherwise
 */
declare function isCssSupported(input: keyof CSSStyleDeclaration | string, value?: string): boolean;

/**
 * Type guard for DOM elements. Uses `instanceof Element` where the global exists, otherwise falls
 * back to duck-typing on `nodeType`/`nodeName` so it also works under SSR and across realms
 * (iframes), where `instanceof` would fail.
 */
declare function isElement(element: unknown): element is Element;

/**
 * Returns true when the node is attached to a parent. Nodes created but never inserted, and nodes
 * already removed, both return false. Shadow roots resolve through their host via `getParentNode`.
 *
 * @param element Node to check.
 * @returns True when the node exists and has a parent.
 */
declare function isExist(element: Node): boolean;

/**
 * Returns true when the element matches the focusable-element selector: `button`, `[href]`, `input`,
 * `select`, `textarea`, `[tabIndex]` or `[contenteditable]`, excluding those that are disabled,
 * hidden, or have `tabindex="-1"`.
 *
 * Matching is purely selector-based — an element hidden by a stylesheet rather than by the `hidden`
 * attribute or an inline `display:none` still counts as focusable.
 *
 * @param element Value to test; non-elements return false.
 * @param selector Extra selector appended to every branch to narrow the match.
 * @returns True when the element is focusable.
 *
 * @example
 * ```ts
 * isFocusableElement(el, ':not(.p-disabled)');
 * ```
 */
declare function isFocusableElement(element: unknown, selector?: string): boolean;

/**
 * Negation of `isVisible`. Returns true for a missing element, and for `position: fixed` elements,
 * which have no `offsetParent` even while rendered.
 */
declare function isHidden(element: HTMLElement): boolean;

/**
 * Returns true when the user agent string identifies iPad, iPhone or iPod, excluding IE Mobile's
 * lookalike UA. Recent iPadOS reports a desktop Safari UA and is not detected. Throws on the server,
 * where `navigator` is undefined — guard with `isClient()`.
 */
declare function isIOS(): boolean;

/**
 * Returns true when the OS reports a `prefers-reduced-motion: reduce` preference. Reads the value
 * once rather than subscribing, so call it at animation time instead of caching the result. Returns
 * false on the server and where `matchMedia` is unavailable.
 */
declare function isPrefersReducedMotion(): boolean;

/**
 * Returns true when the element's computed `direction` is `rtl`, accounting for direction inherited
 * from an ancestor. Resolves against the main document, so cross-document (iframe) elements are not
 * supported.
 *
 * @param element Element to inspect.
 * @returns True when the computed direction is right-to-left; false when no element is given.
 */
declare function isRTL(element?: HTMLElement): boolean;

/**
 * Negation of `isClient`. Returns true when no usable `document` is available, as during SSR.
 */
declare function isServer(): boolean;

/**
 * Returns true when the device exposes touch input, via `ontouchstart` or a non-zero
 * `maxTouchPoints` (including the legacy `msMaxTouchPoints`). Reports true for touch-capable
 * desktops, so it indicates capability rather than the input method actually in use. Throws on the
 * server, where `window` is undefined — guard with `isClient()`.
 */
declare function isTouchDevice(): boolean;

/**
 * Returns true when the element is rendered, determined from `offsetParent`. This is a layout check,
 * not a visibility one: an element hidden by `visibility: hidden` or `opacity: 0` still counts as
 * visible, while a `position: fixed` element counts as hidden because it has no `offsetParent`.
 *
 * @param element Element to inspect.
 * @returns True when the element participates in layout; false when no element is given.
 */
declare function isVisible(element?: HTMLElement): boolean;

/**
 * Positions a submenu against its parent menu item, flipping to the opposite side and shifting
 * upward when the viewport would clip it. Mutates the element's `top` and `insetInlineStart` inline
 * styles; measures hidden elements off-screen so it can run before the submenu is shown.
 *
 * @param element Submenu element to position. Its `parentElement` is taken as the owning menu item.
 * @param level Nesting depth, used to alternate the flip direction on viewports too narrow to fit either side.
 */
declare function nestedPosition(element: HTMLElement, level: number): void;

/**
 * Resolves after two animation frames. The double wait guarantees the browser has committed pending
 * style changes, which is what makes a transition start from freshly applied initial values rather
 * than being collapsed into a single recalculation.
 *
 * @returns A promise resolved on the second frame.
 *
 * @example
 * ```ts
 * el.classList.add('p-enter-from');
 * await nextFrame();
 * el.classList.add('p-enter-active'); // transitions instead of snapping
 * ```
 */
declare function nextFrame(): Promise<void>;

/**
 * Positions an overlay relative to its target, assuming the overlay is absolutely positioned within
 * the target's offset parent. Flips above the target when there is not enough room below, and clamps
 * horizontally to keep the overlay inside the viewport. Mutates the overlay's `top`,
 * `insetInlineStart`, `transformOrigin` and `marginTop` inline styles.
 *
 * Hidden overlays are measured off-screen, so this can run before the overlay is shown.
 *
 * @param element Overlay element to position.
 * @param target Element to anchor against.
 * @param gutter Applies the `--*-anchor-gutter` offset between overlay and target. Defaults to `2px` when the variable is undefined.
 * @param fixedOrigin Pins the overlay to `top` or `bottom`, disabling the automatic flip.
 */
declare function relativePosition(element: HTMLElement, target: HTMLElement | SVGElement, gutter?: boolean, fixedOrigin?: 'top' | 'bottom' | undefined): void;

/**
 * Detaches an element from its parent. No-op for a missing element or one already detached.
 *
 * @param element Element to remove.
 */
declare function remove(element: Element): void;

/**
 * Detaches every `on*` event listener that `setAttribute`/`setAttributes` attached to the element,
 * and clears the internal `_pListeners` tracking array. Despite the name, no attributes are removed —
 * this exists to release listener references on teardown. No-op for a non-`Element` input.
 *
 * @param element Element to detach listeners from.
 */
declare function removeAttributes(element: HTMLElement): void;

/**
 * Removes a child node from a parent given as any reference `toElement` accepts — a framework ref,
 * a getter function, or an element.
 *
 * @param element Parent reference to remove the child from.
 * @param child Node to remove.
 * @throws Error when the parent reference does not resolve to an element.
 */
declare function removeChild(element: unknown, child: Node): void;

/**
 * Removes one or more classes from an element. Accepts an array and space-separated strings; empty
 * and nullish entries are skipped. Falls back to a regex over `className` on elements without
 * `classList` (legacy SVG). No-op for a missing element or class.
 *
 * @param element Element to modify.
 * @param className Class name, space-separated list, or array of either.
 *
 * @example
 * ```ts
 * removeClass(el, 'p-focus p-highlight');
 * removeClass(el, ['p-focus', condition && 'p-highlight']);
 * ```
 */
declare function removeClass(element: Element, className: string | undefined | null | (string | undefined | null)[]): void;

/**
 * Removes an injected `<style>` element from the document. Swallows removal errors, which occur when
 * a hot-reload has already detached the node.
 *
 * @param element Style element to remove.
 * @returns `null` when the element was attached, so the caller can clear its reference; the element unchanged when it was already detached.
 *
 * @example
 * ```ts
 * styleRef = removeStyleTag(styleRef);
 * ```
 */
declare function removeStyleTag(element: Node): Node | null;

/**
 * Resolves a CSS custom property to its computed color.
 *
 * Unlike `getCSSProperty`, which returns the raw declaration text, this substitutes the variable
 * into a probe element so the browser computes it — resolving `light-dark()`, `color-mix()` and
 * nested `var()` chains.
 *
 * @param variableName Custom property name, with or without the leading `--`. Names outside
 * `[A-Za-z0-9_-]` are rejected, so a crafted name cannot break out of the probe's declaration.
 * @param parent Scope to resolve against, for variables not defined on `:root`. Defaults to `document.body`.
 * @returns The computed color, or `null` when the variable is undefined, malformed, or the DOM is unavailable.
 *
 * @example
 * ```ts
 * resolveCSSColor('--p-primary-color'); // 'rgb(16, 185, 129)'
 * resolveCSSColor('--p-host-token', shadowRoot);
 * ```
 */
declare function resolveCSSColor(variableName?: string, parent?: Element | ShadowRoot | null): string | null;

/**
 * Parses the user agent string into an engine/browser name and version. Recognises `chrome`,
 * `webkit`, `opera`, `msie` and `mozilla` only — every Chromium browser reports `chrome`, and Safari
 * reports `webkit`. Throws on the server, where `navigator` is undefined — guard with `isClient()`.
 *
 * @returns Lowercase browser name and version; `{ browser: '', version: '0' }` when nothing matches.
 */
declare function resolveUserAgent(): {
    browser: string;
    version: string;
};

/**
 * Scrolls a container by the minimum amount needed to bring an item into view, accounting for the
 * container's top border and padding. Items already fully visible are left alone. Scrolls vertically
 * only, and mutates `container.scrollTop`.
 *
 * Reads computed style from the main document, so cross-document (iframe) elements are not supported.
 *
 * @param container Scrollable ancestor to scroll.
 * @param item Descendant to bring into view.
 */
declare function scrollInView(container: HTMLElement, item: HTMLElement): void;

/**
 * Returns true when a CSS value can execute script. Rejects legacy IE `expression()`, `javascript:`
 * and `vbscript:` URLs in `url()`, script-bearing `@import`, and any `data:` URL in `url()` that is
 * not a base64 image of a known raster type — a `data:text/html` background is a script vector.
 *
 * Screens values before they reach a style declaration; non-strings are treated as safe, since they
 * cannot carry a URL.
 *
 * @param value Declaration value to screen.
 * @returns True when the value must be rejected.
 */
declare function hasUnsafeCssValue(value: unknown): boolean;
/**
 * Returns true when a URL-bearing attribute (`href`, `src`, `xlink:href`, `action`, `formaction`)
 * holds a value whose scheme is not allowed — blocking `javascript:` and comparable script-executing
 * schemes. Relative and fragment URLs pass, as do `http`, `https`, `mailto`, `tel`, `sms`, `ftp`,
 * `ftps` and `blob`. `data:` passes only on `src`/`xlink:href` and only for base64 raster images.
 *
 * The scheme is read after stripping control characters and whitespace, so obfuscations such as
 * `java\nscript:` do not slip through. Attributes outside the URL set are not screened here.
 *
 * @param attribute Attribute name; matched case-insensitively.
 * @param value Attribute value to screen.
 * @returns True when the attribute must not be set.
 */
declare function isUnsafeUrlAttribute(attribute: string, value: unknown): boolean;
/**
 * Returns true when an `srcdoc` value carries markup that would execute in the nested browsing
 * context — a `<script>` tag, an inline `on*` handler, a `javascript:` URL, or `data:text/html`.
 * Only `srcdoc` is screened; every other attribute returns false.
 *
 * @param attribute Attribute name; matched case-insensitively.
 * @param value Attribute value to screen.
 * @returns True when the attribute must not be set.
 */
declare function isUnsafeHtmlAttribute(attribute: string, value: unknown): boolean;
declare const _default: {
    hasUnsafeCssValue: typeof hasUnsafeCssValue;
    isUnsafeUrlAttribute: typeof isUnsafeUrlAttribute;
    isUnsafeHtmlAttribute: typeof isUnsafeHtmlAttribute;
};

/**
 * Sets a single attribute, with three special cases:
 *
 * - `on*` names attach an event listener instead of an attribute, deduplicated per event name so a
 *   repeated call replaces the previous handler rather than stacking. Detach via `removeAttributes`.
 * - `style` is applied declaration by declaration through the CSP-safe path, accepting a string or an
 *   object and replacing any existing inline style. Values that could execute script are dropped.
 * - Attributes carrying an unsafe URL or `srcdoc` payload are silently skipped.
 *
 * `null` and `undefined` values are ignored — they do not clear the attribute. No-op for a
 * non-`Element` input.
 *
 * @param element Element to modify.
 * @param attribute Attribute name.
 * @param value Value to set, an event listener, or a style string/object.
 */
declare function setAttribute(element: HTMLElement, attribute: string | undefined, value: unknown): void;

/**
 * Sets many attributes at once, merging `class` and `style` rather than overwriting them. Both accept
 * nested arrays and objects: for `class`, object keys with a truthy value are kept and duplicates are
 * dropped; for `style`, camelCase keys are hyphenated and object values become declarations. Previous
 * values are read back from a `$attrs` bag stored on the element, so repeated calls accumulate.
 *
 * `on*` keys attach event listeners (deduplicated per event name; detach via `removeAttributes`), and
 * a `p-bind`/`pBind` key is applied recursively as a nested attribute set. Attributes carrying an
 * unsafe URL or `srcdoc` payload, and style values that could execute script, are silently skipped.
 *
 * `null` and `undefined` values are ignored. No-op for a non-`Element` input.
 *
 * @param element Element to modify.
 * @param attributes Attribute map. Keys may be attribute names, `on*` listeners, or `p-bind`/`pBind`.
 *
 * @example
 * ```ts
 * setAttributes(el, {
 *     class: ['p-button', { 'p-disabled': disabled }],
 *     style: { marginTop: '2px' },
 *     onClick: handler,
 *     'p-bind': ptOptions
 * });
 * ```
 */
declare function setAttributes(element: HTMLElement, attributes?: {
    [key: string]: unknown;
}): void;

/**
 * Sets an inline CSS property, custom properties included. No-op when the element or property is
 * missing. Unlike `setAttribute`, the value is not screened for unsafe CSS — do not pass untrusted
 * input.
 *
 * @param element Element to modify.
 * @param property Property name; `--`-prefixed for custom properties.
 * @param value Value to set. `null` removes the declaration.
 * @param priority Pass `'important'` to set the priority flag.
 *
 * @example
 * ```ts
 * setCSSProperty(el, '--p-primary-color', '#10b981');
 * ```
 */
declare function setCSSProperty(element?: HTMLElement, property?: string, value?: string | null, priority?: string): void;

/**
 * Converts various framework-specific element references to a DOM HTMLElement
 * Supports:
 * - React refs: { current: HTMLElement }
 * - Vue refs: { value: HTMLElement }
 * - Lit refs: { value: HTMLElement }
 * - Angular ViewChild: { nativeElement: HTMLElement }
 * - Vue template ref: { el: HTMLElement }
 * - Direct HTMLElement
 *
 * @param ref Framework-specific element reference
 * @returns The resolved HTMLElement or undefined if not found
 */
declare function toElement(ref: unknown): HTMLElement | undefined;

export { absolutePosition, addClass, addStyle, alignOverlay, appendChild, applyEventListener, _default$1 as applyStyle, blockBodyScroll, calculateBodyScrollbarWidth, calculateScrollbarHeight, calculateScrollbarWidth, clearSelection, createElement, createStyleAsString, createStyleElement, createStyleMarkup, createStyleTag, escapeAttribute, exportCSV, fadeIn, fadeOut, find, findSingle, focus, getAttribute, getBrowser, getBrowserLanguage, getCSSProperty, getCSSVariableByRegex, getCursorOffset, getFirstFocusableElement, getFocusableElements, getHeight, getHiddenElementDimensions, getHiddenElementOuterHeight, getHiddenElementOuterWidth, getIndex, getInnerWidth, getLastFocusableElement, getNextElementSibling, getNextFocusableElement, getOffset, getOuterHeight, getOuterWidth, getParentNode, getParents, getPreviousElementSibling, getScrollLeft, getScrollableParents, getSelection, getTargetElement, getUserAgent, getViewport, getWidth, getWindowScrollLeft, getWindowScrollTop, hasCSSAnimation, hasCSSTransition, hasClass, invokeElementMethod, isAndroid, isAttributeEquals, isAttributeNotEquals, isClickable, isClient, isCssSupported, isElement, isExist, isFocusableElement, isHidden, isIOS, isPrefersReducedMotion, isRTL, isServer, isTouchDevice, isVisible, nestedPosition, nextFrame, relativePosition, remove, removeAttributes, removeChild, removeClass, removeStyleTag, resolveCSSColor, resolveUserAgent, saveAs, scrollInView, _default as security, setAttribute, setAttributes, setCSSProperty, toElement, unblockBodyScroll };