import{type PropertyValues,type TemplateResult}from'lit';import type{Placement}from'@floating-ui/dom';import{LyraElement}from'../../../internal/lyra-element.js';import type{PlaceStrategy,PlaceSync}from'../../../internal/positioner.js';import{type LyraArrowPlacement}from'./overlay-arrow.js';import{type OverlayVirtualRect}from'./overlay-shared.js';
/** Semantic role vocabulary for a popover surface or mapped trigger contract. */
/**
* Semantic role a popover's positioned surface takes on.
*
* `'none'` is the escape hatch for the WAI-ARIA **disclosure navigation** pattern: a list of links
* is not an application action menu (`'menu'` announces "menu, menu item" and expects `menuitem`
* children) and is not an interruptive surface (`'dialog'`). Under `'none'` the popover contributes
* positioning, light dismiss, and the `aria-expanded`/`aria-controls` wiring the disclosure pattern
* requires, while the author's own `<nav>`/`<ul>` inside owns the semantics and the accessible
* name. No `role` and no generated `aria-label` are emitted, and the trigger carries no
* `aria-haspopup` -- a disclosure button does not own a popup, and `aria-haspopup="none"` is an
* invalid attribute value that axe flags as a critical violation.
*/
export type LyraPopupRole='dialog'|'menu'|'none';
/**
* One keyword of the space-separated `trigger` list -- the same vocabulary, spelled the same way,
* that `<lr-tooltip>`'s `trigger` accepts, so `trigger="hover focus"` means one thing everywhere in
* this library.
*
* `'click'` is the shipped behaviour and stays the default. `'hover'` and `'focus'` are the two
* transient modes: they open after `showDelay`, close after `hideDelay` once the interaction ends,
* never move focus into the surface on their own, and can be *pinned* open by a click on the
* trigger (a second click releases the pin and closes). `'manual'` refuses every interaction and
* leaves the surface entirely to `show()`/`hide()`/`open`, and wins over any keyword beside it.
*/
export type LyraPopoverTrigger='click'|'hover'|'focus'|'manual';export type{LyraArrowPlacement,OverlayVirtualRect,PlaceStrategy};
/** The `showAt()` rectangle, shared verbatim with `<lr-tooltip>` (see `./overlay-shared.ts`). */
export interface LyraPopoverEventMap{'lr-show':CustomEvent<null>;'lr-after-show':CustomEvent<null>;'lr-hide':CustomEvent<null>;'lr-after-hide':CustomEvent<null>;}
/**
* `<lr-popover>` — a light-dismiss floating surface, click-triggered by default.
*
* `trigger` selects which interaction opens it: `click` (the shipped default), `hover`, `focus`,
* or `manual`. The two transient modes open after `showDelay`, close after `hideDelay` once the
* interaction ends, deliberately never move focus into the surface, and keep it open while focus
* rests anywhere inside it. A click on the trigger while a transient surface is open *pins* it --
* the pointer may then leave without closing it -- and the next click releases the pin. Set
* `hover-bridge` to have the positioner clip an invisible quad across the `distance` gap so a
* pointer travelling from the trigger to the popup never leaves both at once.
*
* Interaction/ARIA ownership is resolved separately from positioning. A slotted trigger wins and
* receives the click listener plus `aria-haspopup`, `aria-expanded`, and `aria-controls`; without
* one, a live HTML element resolved by `for` owns the same contract. A wrapper/custom trigger's
* real composed focus target receives the same owned semantics and is the focus-return target. A
* direct `.anchor` is positioning-only. `showAt()`'s virtual anchor wins positioning and
* deliberately has no DOM interaction/ARIA owner while active.
* The component supplies the real shadow popup to the shared relationship controller. Current
* browsers expose its nearest public shadow host to a light-DOM trigger, keeping the relationship
* resolvable without pretending a private idref crosses the boundary.
* Live `popupRole`, host-id, target-id, and target-identity changes keep those relationships
* synchronized. Losing the sole live positioning anchor force-closes the surface; if a slotted or
* `for` fallback remains, the popover repositions to it and stays open. A deliberate `showAt()`
* virtual anchor remains open independently of DOM-anchor removal.
*
* Lifecycle: `show()` emits `lr-show` (cancelable) and then `lr-after-show` once the popup's
* transition has finished; `hide()` emits `lr-hide` (cancelable) then `lr-after-hide`. Assigning
* `open` runs the same sequence, so the property, the reflected attribute and the two methods can
* never disagree. Markup that renders open from the start emits nothing.
* Motion resolves through `popover.show`/`popover.hide` in the public animation registry.
*
* Positioning resolves `showAt()` virtual anchor, direct `.anchor`, `for`, then the interaction
* owner, in that order. Thus `anchor` can position against an element that never receives click or
* ARIA state, while `for` owns both positioning and interaction only when no trigger is slotted.
* Activating an enabled, non-inert light-DOM descendant with `data-popover="close"` requests this
* closest owning popover to close. Nested popovers consume their own close actions.
*
* Open popovers, dropdowns and tooltips reposition when their effective host or inherited text direction changes, preserving open state and lifecycle events.
*
* @customElement lr-popover
* @slot trigger - The highest-priority interaction/ARIA owner; toggles the popover even when
*   positioning uses `anchor` or `for`.
* @slot - Popover content. An enabled, non-inert descendant with `data-popover="close"` closes its
*   nearest owning popover when activated.
* @event lr-show - The popover is about to open. Cancelable — `preventDefault()` keeps it closed.
* @event lr-after-show - The popover is open and its transition has finished.
* @event lr-hide - The popover is about to close, for every dismissal path (Escape, light
*   dismiss, `hide()`, `open = false`). Cancelable — `preventDefault()` keeps it open.
* @event lr-after-hide - The popover is closed and its transition has finished.
* @method show - `show(): Promise<void>` — programmatically open and resolve after
*   `lr-after-show`.
* @method hide - `hide(options?: { focusTrigger?: boolean }): Promise<void>` — programmatically
*   close and resolve after `lr-after-hide`. Focus returns to the slotted/`for` interaction owner
*   by default, matching Escape, light dismiss, and `el.open = false`; pass
*   `focusTrigger: false` to preserve the current focus instead.
* @csspart trigger - The trigger wrapper.
* @csspart hover-bridge - The invisible quad bridging the trigger and the popup, rendered only
*   while a `hover` popover with `hover-bridge` set is open.
* @csspart popup - The positioned popup; also carries `dialog` and `popup__popup` aliases.
* @csspart dialog - Mapped alias on the positioned popup.
* @csspart popup__popup - Exported popup alias on the positioned popup.
* @csspart content - The content wrapper; also carries the `body` alias.
* @csspart body - Mapped alias on the content wrapper.
* @csspart arrow - The arrow element, rendered only when `arrow` is set. Its part name also
*   carries the resolved side (`arrow-top`, `arrow-bottom`, `arrow-left`, `arrow-right`), so
*   `::part(arrow arrow-top)` can style one side — state after `::part()` never matches.
* @csspart popup__arrow - Exported mapped alias on the arrow.
* @cssprop [--max-width=var(--lr-overlay-max-inline-size,var(--lr-size-20rem))] - Maximum inline
* size of the popup.
* @cssprop --lr-overlay-max-inline-size - Retained Lyra fallback for `--max-width`.
* @cssprop [--arrow-size=var(--lr-overlay-arrow-size,var(--lr-size-0-375rem))] - Half-width of the
* arrow square.
* @cssprop --lr-overlay-arrow-size - Retained Lyra fallback for `--arrow-size`.
* @cssprop [--lr-overlay-surface=var(--lr-color-surface-overlay)] - Shared floating-surface fill,
*   read by the popup and by its arrow. One declaration on any ancestor retints every overlay in
*   that subtree without touching the page, card and control surfaces behind them.
* @cssprop [--lr-overlay-border=var(--lr-color-border)] - Shared floating-surface edge colour, on
*   the popup and on the arrow's two outward-facing edges.
* @cssprop [--lr-overlay-radius=var(--lr-radius)] - Shared floating-surface corner radius. The
*   arrow is deliberately excluded: its corners are already cut by its clip path.
* @cssprop [--lr-overlay-shadow-anchored=var(--lr-shadow-m)] - Elevation of an anchored,
*   positioner-placed overlay. A separate tier from `--lr-overlay-shadow-modal`, so raising popups
*   never raises dialogs.
* @cssprop [--show-duration=var(--lr-duration-fast)] - Opening transition duration.
* @cssprop [--hide-duration=var(--lr-duration-fast)] - Closing transition duration.
* @cssprop --lr-positioning-strategy - Cascading `absolute`/`fixed` override for
*   {@link positioningStrategy}, read from computed style when the popup is (re)positioned. Set it
*   once on `:root`, a theme, or one clipping ancestor to change every unset overlay beneath it
*   without authoring `positioning-strategy`/`hoist` on each instance; an explicit value on the
*   instance always wins over it.
* @cssstate open - Present while the popover is open.
* @status stable
* @since 4.0.0
*/
export declare class LyraPopover<Events extends LyraPopoverEventMap=LyraPopoverEventMap>extends LyraElement<Events>{static styles:import("lit").CSSResultGroup[];private _open;
/** Whether the popover is open. Assigning it runs the full `lr-show`/`lr-hide` lifecycle.
* @default false */
get open():boolean;set open(next:boolean);placement:Placement;private _positioningStrategy?;
/**
* CSS positioning scheme the popup is laid out with -- the one property `<lr-popover>`,
* `<lr-dropdown>` and `<lr-select>` all spell the same way. `fixed` normally positions against
* the viewport, so it escapes most clipping ancestors; `absolute` positions against the popup's
* containing block and scrolls with it. Each component keeps its own mirrored default, so
* setting nothing on the instance and on every ancestor never changes what it already rendered;
* an unsupported authored value resolves to that same default. Changes apply live while open.
* This property reports only the instance's own authored value (or the mirrored default); the
* popup is actually placed with the `--lr-positioning-strategy` cascading custom property
* honored ahead of that default when the instance itself sets nothing -- see that `@cssprop`.
* @default 'fixed'
*/
get positioningStrategy():PlaceStrategy;set positioningStrategy(next:PlaceStrategy);
/** Mapped subclasses that also publish the retained `hoist` boolean alias keep the two spellings
*  reflecting together from here; the generic popover has no such alias and does nothing. */
protected onPositioningStrategyChanged(_previous:PlaceStrategy,_next:PlaceStrategy):void;
/** Anchor-offset distance (px) passed to Floating UI's `offset()` middleware. Can legitimately
*  be negative (overlaps the popup with the trigger); NaN/non-finite falls back to the default. */
distance:number;
/** Offset along the anchor's edge, in pixels — Floating UI's cross-axis offset. */
skidding:number;
/**
* Id of an element elsewhere in this popover's own root. It participates in positioning behind
* a direct `.anchor`; when it resolves to a live HTML element and no trigger is slotted, that
* element also owns click and ARIA. A slotted trigger still wins interaction ownership, and a
* `showAt()` virtual anchor wins positioning while suppressing every DOM interaction owner.
*/
private _for;get for():string;set for(next:string|null);
/** Positioning-only element anchor. Takes precedence over `for` and the interaction owner, but
*  never receives click listeners or generated ARIA. */
anchor:Element|null;
/** Render an arrow that points at the anchor. Defaults on for the mapped surface. */
arrow:boolean;
/** Positive mapped spelling for suppressing the default arrow. */
withoutArrow:boolean;
/** Where the arrow sits along the popup's edge. `anchor` tracks the anchor's centre. */
arrowPlacement:LyraArrowPlacement;
/** Keeps the arrow this far from the popup's corners, in pixels. */
arrowPadding:number;private _trigger;
/**
* Space-separated list of the interactions that open the popover -- see
* {@link LyraPopoverTrigger} for the keywords, which are exactly `<lr-tooltip>`'s. Unrecognized
* tokens are dropped and a list left with none resolves back to `'click'`, so the property always
* reads back as a canonical list.
* @type {string}
* @default 'click'
*/
get trigger():string;set trigger(next:string);
/** The resolved interaction keywords, always at least one. */
private get triggerKeywords();
/** `manual` beats every other keyword: a surface an author declared programmatic must not still
*  be openable by a stray `hover` left beside it. */
protected get isManualTrigger():boolean;
/** Whether `keyword` is one of the interactions currently allowed to open this popover. */
protected opensOn(keyword:LyraPopoverTrigger):boolean;
/** Delay (ms) between a `hover`/`focus` interaction and the popover opening. NaN, negative and
*  oversized values all normalize through `finiteDuration`.
*  @default 0 */
showDelay:number;
/** Delay (ms) between the interaction ending and the popover closing again -- the grace period
*  that lets a pointer cross the gap to the popup. Normalized like {@link showDelay}.
*  @default 0 */
hideDelay:number;
/**
* Renders an invisible `[part='hover-bridge']` quad spanning the `distance` gap between the
* trigger and the popup while a `hover` popover is open, so a pointer travelling between them
* never leaves both at once and the popover does not close underneath it. Off by default: it is
* only meaningful for `trigger="hover"`, and a page that keeps `distance` at `0` does not need
* it.
* @default false
*/
hoverBridge:boolean;
/** Accessible name for the semantic popup. An authored host `aria-label` wins by presence,
*  including an explicitly empty value, before this property or the localized role fallback. */
accessibleLabel:string;private _popupRole;
/** Semantic role used by the popup. `dialog` (default) for a contextual surface, `menu` for an
*  action menu, or `none` to render no role and no generated name so the slotted content owns
*  its own semantics -- see `LyraPopupRole` for why a navigation disclosure needs that.
*  Unsupported attribute values and untyped property writes normalize to `dialog` before the
*  role or trigger ARIA is rendered.
*  @default 'dialog' */
get popupRole():LyraPopupRole;set popupRole(next:LyraPopupRole);private _disabled;
/** Prevents opening the popover -- pointer, keyboard, and programmatic `show()`/`open = true`
*  are all refused while set. Becoming disabled also closes an already-open popover; initial
*  `disabled` plus `open` markup/property state normalizes closed in either order. Mirrors
*  `<lr-tooltip>`'s and `<lr-dropdown>`'s own `disabled`.
*  @default false */
get disabled():boolean;set disabled(next:boolean);private triggerElement?;private slottedTrigger?;private triggerSlotElement?;
/**
* True while the surface was opened by a transient `hover`/`focus` interaction rather than a
* click or a programmatic call. It gates two things: the surface closes again when the
* interaction ends, and it never pulls focus (`onPopupPositioned()`), because a popover that
* appeared because the pointer drifted over a trigger must not steal the caret from whatever
* the user is actually typing into.
*/
protected openedByInteraction:boolean;
/** A click on the trigger pins a `hover`/`focus` popover open: the pointer leaving or focus
*  moving away stops closing it, and the next click releases the pin and closes. Transient
*  state -- reset on every close and on disconnect. */
private pinned;
/** True for exactly as long as a close is handing focus back to the trigger. Without it a
*  `focus`-triggered popover reopens the instant it closes, because the restoration IS a focusin
*  on the trigger -- and it reopens from inside `updated()`, which is also what trips Lit's
*  change-in-update warning. */
private suppressTriggerFocusOpen;private delayTimer?;private delayTimerView?;private pendingDirection?;private resolvedSide;private anchorPositioned;private positionedAnchor?;private positioningDirection?;private directionChanged;private observedDirectAnchor?;private observedDirectAnchorWasConnected;private stopAnchorIdentityObservation?;private triggerAria?;private accessibleTriggerAria?;
/** The virtual anchor set by `showAt()`, taking priority over `trigger` for positioning while
*  set. Cleared whenever the popover closes, so a later `open = true` with no fresh `showAt()`
*  call reverts to plain trigger-based behavior. */
private virtualAnchor?;
/** `options.returnFocusTo` from the `showAt()` call that opened the popover, if any -- see
*  `showAt()`'s doc comment and `activatePopoverOverlay()`'s focus-return configuration. */
private returnFocusTo?;private cleanup?;private positioningGeneration;private positioningReady;private resolvePositioningReady?;
/** Registered with the shared overlay manager while every popover is open, so one topmost stack
*  owns Escape and focus restoration. */
private overlayHandle?;private readonly generatedHostId;private readonly popupId;private lightDismissDocument?;private hostIdObserver?;private hostIdObserverDocument?;private hostIdObserverGeneration;
/** Invalidates an in-flight `lr-after-*` wait when the opposite transition interrupts it. */
private transitionToken;private transitionAnimation?;private readonly transitionGate;private connectionSequence;private readonly popoverInternals;
/** Subclass seam for mapped overlays whose public distance default differs from the popover. */
protected get defaultDistance():number;
/** The strategy this component resolves to when nothing has been authored. A subclass keeps its
*  own mirrored default here rather than changing the shared property's meaning. */
protected get defaultPositioningStrategy():PlaceStrategy;
/** Positioning hook for mapped overlays that expose Floating UI's sync surface. */
protected get positioningSync():PlaceSync|undefined;
/** Registry namespace and token fallbacks are override seams for mapped dropdowns. */
protected get animationNamespace():string;protected animationDurationProperties(showing:boolean):readonly string[];
/** Additive part aliases for mapped subclasses. `popup`/`content` remain present. */
protected get popupPartNames():string;protected get contentPartNames():string;
/** The role announced by the interaction trigger. Mapped subclasses can keep this semantic
* invariant even when their positioned wrapper is deliberately presentation-only. */
protected get triggerPopupRole():LyraPopupRole;
/** Semantic role owned by the positioned surface. Dropdown overrides this because its contained
* menu is the real role/name owner and the outer element contributes positioning chrome only.
* `'none'` reaches the same undefined result by author request rather than by subclass. */
protected get popupSurfaceRole():LyraPopupRole|undefined;
/** Resolved popup name, also available to a mapped subclass that delegates role ownership to a
* contained semantic component. Presence-based host naming preserves an authored empty label. */
protected get effectivePopupLabel():string;
/** Subclasses can retain a different arrow default without forking rendering/positioning. */
protected get rendersArrow():boolean;
/** The bridge only exists while a hover popover is actually open: it is a full-viewport element
*  clipped to the trigger/popup quad, and one left behind while closed would be an invisible
*  hit-test surface over the page. */
protected get rendersHoverBridge():boolean;
/** Subclass opening invariant, checked for initial property/attribute replay and every later
* imperative `show()`. A disabled popover is never eligible to open. */
protected get canOpen():boolean;
/** Generic popovers project their default slot directly. A mapped subclass can insert an owned
* interaction controller without replacing the trigger/popup shell. */
protected renderPopupContent():unknown;
/** Trigger-key extension point. Generic popovers deliberately retain click-only toggling. */
protected onTriggerKeyDown(_event:KeyboardEvent):void;
/** A `for` trigger lives outside the shadow wrapper that normally delegates key events. */
private onExternalTriggerKeyDown;
/** Lets a mapped subclass include a separate containing element in its dismiss boundary. */
protected isInsideLightDismissBoundary(path:EventTarget[]):boolean;
/** Runs once when a newly opened/re-anchored popup has completed its first placement and is no
*  longer visibility-hidden. Focus cannot reliably enter a visibility-hidden subtree in Firefox
*  or WebKit, so autofocus and mapped menu focus wait for this readiness boundary. */
protected onPopupPositioned():void;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;protected firstUpdated(changed:PropertyValues):void;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;private syncAnchorIdentityObservation;private resolveForTrigger;private syncInteractionTrigger;
/** Registers every open popover with the shared, topmost-stack-aware overlay manager. Popovers
*  remain nonmodal and non-focus-trapping; the manager owns Escape and restoration to the
*  trigger (or a virtual anchor's explicit `returnFocusTo`). */
private activatePopoverOverlay;
/** Updates the eventual focus-return target without changing this popover's overlay-stack
*  identity. Re-registering would promote an underlying popover above a newer overlay and, when
*  this popover is already topmost, briefly move focus into the overlay underneath. */
private updatePopoverRestoreFocusTarget;
/**
* Opens the popover anchored to an arbitrary rectangle instead of any DOM anchor -- for
* anchoring to a graph node, a canvas pixel, a chart datum, or any other non-DOM location.
* `width`/`height` default to `0` (a point). Positions exactly as `place()` would against a real
* element (flip/shift/RTL all apply unchanged).
*
* A virtual anchor has no DOM node, so `autoUpdate()` can't track it moving on its own -- call
* `showAt()` again with fresh coordinates to re-anchor an already-open popover (e.g. on a graph
* pan/zoom tick); the popover stays open across such a call, it does not toggle. Pass
* `rect.contextElement` (a real, still-connected element near the virtual point) when available
* so `autoUpdate()` has something to observe for ancestor-scroll/resize tracking; omitting it
* still works, it just means only explicit re-`showAt()` calls keep the popover anchored.
*
* While the virtual anchor is active, no slotted/`for` element owns click or generated ARIA.
* A virtual anchor also has no `.focus()`. Escape, light dismiss, and programmatic close return
* focus to `options.returnFocusTo` when supplied, or skip focus-return entirely otherwise --
* refocusing the right place after a virtual anchor closes is the host's responsibility, since
* Lyra can't assume how e.g. a graph node's own keyboard model wants focus back.
* Non-finite coordinates or dimensions are ignored and leave the current open/anchor state
* unchanged.
*/
showAt(rect:OverlayVirtualRect,options?:{returnFocusTo?:HTMLElement;}):void;
/** Resolves what the popup is positioned against: an explicit virtual anchor first, then the
*  direct `anchor`, then the `for` idref, then the slotted trigger. Shared with `<lr-tooltip>`,
*  which resolves the identical chain. */
private resolveAnchor;protected positionPopup():void;private invalidatePositioning;private resolveCurrentPositioning;private startPositioning;private syncTriggerA11y;private get accessibleTrigger();private releaseTriggerA11y;private onTriggerSlotChange;
/**
* Reads the named `trigger` slot's currently assigned element and applies it -- wired as the
* `slotchange` handler (via `onTriggerSlotChange`) for every later mutation, and called once
* more from `firstUpdated()` (see `collectInitialSlotAssignment`) to cover an environment, or a
* real-browser timing race, where the slot's initial assignment never fires `slotchange`.
* Idempotent: a second call that reads back the same assigned element is a no-op past the
* `next === this.slottedTrigger` guard.
*/
private collectTriggerFromSlot;private onTriggerClick;private onTriggerPointerEnter;private onTriggerPointerLeave;private onPopupPointerEnter;private onPopupPointerLeave;private onSurfaceFocusIn;private onSurfaceFocusOut;
/** The shared "the interaction that was holding this open has ended" path. Retention beats
*  closing: a pinned surface, a pointer/focus target still inside the trigger or the popup, and
*  focus resting anywhere within the surface each keep it open. */
private requestInteractionClose;
/** Whether `target` is the trigger, the popup, or anything inside either -- across slots and the
*  shadow boundary, which a plain `contains()` cannot see. */
private isWithinPopoverSurface;
/**
* Whether focus is resting somewhere that should keep a transient surface open.
*
* The TRIGGER is deliberately excluded. Focus lands there routinely without the user asking --
* a click that pinned the surface, and every close path that restores focus to it -- so counting
* it as retention would leave a `hover` popover that can never close once it has been clicked.
* Only focus inside the popup (or the host's own slotted content) is a reason to stay.
*/
private hasFocusWithinSurface;
/**
* Runs `show()`/`hide()` after the matching delay, replacing whatever was already pending.
*
* `deferImmediate` keeps a zero (or negative) delay off the *current* task instead of committing
* inline. Every interaction path wants the inline commit -- a zero-delay hover must open in the
* same turn the pointer arrived. The one caller that must not is `updated()`'s delay re-arm:
* committing there writes `open` from inside an update, which is the Lit change-in-update the
* combobox's own `refreshQueued` branch exists to avoid.
*/
private requestDelayedTransition;private cancelPendingTransition;
/** Whether `trigger` needs its OWN focus listeners. `focusin`/`focusout` bubble, so a trigger
*  that sits inside this host (the slotted shape) already reaches the host-level pair bound in
*  `connectedCallback()`; a `for` target lives outside the host entirely and would otherwise
*  never deliver a focus event to this popover at all. Binding both would double-fire the
*  handler, so the containment test -- not just `!== slottedTrigger` -- decides. */
private triggerNeedsOwnFocusListeners;private bindTriggerInteractions;private unbindTriggerInteractions;private onPopupClick;private onDocumentPointer;private startLightDismiss;private stopLightDismiss;private observeHostId;private resetHostIdObserver;private setOpen;
/** A vetoed transition must leave the reflected attribute agreeing with the property; Lit only
*  reflects properties it saw change. */
private syncOpenAttribute;
/** Open the popover. Emits `lr-show` first — vetoing it leaves the popover closed — and
*  `lr-after-show` once the popup's transition has finished. */
show():Promise<void>;
/** Programmatically close the popover and return focus to its trigger by default, matching
*  Escape, light dismiss, and a bare `el.open = false`. Pass `{ focusTrigger: false }` to opt
*  out and leave focus where it is. Virtual anchors restore their explicit `returnFocusTo`.
*  Emits `lr-hide` first — vetoing it leaves the popover open — then `lr-after-hide`. */
hide(options?:{focusTrigger?:boolean;}):Promise<void>;
/** Generic DOM-anchored popovers are a same-root singleton. Dropdown subclasses and virtual
* `showAt()` surfaces are intentionally outside that contract. A peer veto leaves the newcomer
* closed; focus never jumps through the retiring peer's trigger during the handoff. */
private closePopoverPeers;
/** Reconciles initially open public popovers after connection without inventing a show/hide
* lifecycle. The most recently connected peer owns the root; mapped dropdowns, virtual
* surfaces, and peers in another document/shadow root remain independent. */
private reconcileInitialPopoverPeers;
/** Structurally retires superseded initial markup. This deliberately skips every lifecycle
* event and focus restoration because no user-initiated open transition occurred. */
private closeForInitialPeerReconciliation;
/** The close half of `hide()` without the veto point, for structural teardown that leaves an
*  open surface with no live positioning anchor. */
private forceClose;private cancelTransitionAnimation;
/**
* `emit()` pinned to this class's own base event map.
*
* `Events` is a type parameter here so `<lr-dropdown>` can widen the map, which leaves
* `LyraEmitArgs<Events, K>` an unresolved conditional type that no concrete argument list can be
* checked against. The `Events extends LyraPopoverEventMap` constraint already guarantees these
* four lifecycle events keep their detail-less shape, so resolve them against the base map.
*/
private emitCancelableLifecycle;private emitSettledLifecycle;
/** Resolves once the registry-backed popup animation has finished, then emits the matching
* `lr-after-*` event. A disabled registration retains the lifecycle without native motion. */
private settleTransition;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-popover':LyraPopover;}}