import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import'./app-rail-item.class.js';
/** The rail's effective presentation -- see the class doc for what each renders. */
export type LyraAppRailMode='full'|'icon-only'|'mobile';
/** {@link LyraAppRailMode} plus the `'auto'` release sentinel -- broader than `forceMode`'s own
*  `LyraAppRailPreferredMode | 'auto'` type, since `forceMode` excludes `'mobile'` (the mobile
*  breakpoint is always tracked automatically and can never be pinned; see its own doc). */
export type LyraAppRailModeInput=LyraAppRailMode|'auto';
/** The non-mobile axis of {@link LyraAppRailMode} -- what `preferred-mode`/`forceMode` can
*  manually prefer between, since the `mobile-breakpoint` continues to be tracked automatically
*  regardless (see `preferredMode`'s own doc). */
export type LyraAppRailPreferredMode=Exclude<LyraAppRailMode,'mobile'>;
/** Whitespace-separated tokens accepted by the `persist` attribute. */
export type LyraAppRailPersistField='open'|'width'|'preferred-mode';export interface LyraAppRailModeChangeDetail{mode:LyraAppRailMode;}export interface LyraAppRailToggleDetail{open:boolean;}export interface LyraAppRailResizeDetail{widthPx:number;}
/**
* Pure breakpoint-to-mode resolver, kept separate from the `matchMedia`
* wiring below so it's directly unit-testable without resizing a real
* browser window. `mobileMatches` wins over everything else when true (the
* viewport is narrower than both breakpoints at once); otherwise
* `preferredMode` (when set) wins over `iconOnlyMatches` — a manual
* preference for the full/icon-only axis specifically, while the mobile
* breakpoint continues to be tracked automatically regardless.
*/
export declare function computeAppRailMode(iconOnlyMatches:boolean,mobileMatches:boolean,preferredMode?:LyraAppRailPreferredMode|null):LyraAppRailMode;export interface LyraAppRailEventMap{'lr-mode-change':CustomEvent<LyraAppRailModeChangeDetail>;'lr-toggle':CustomEvent<LyraAppRailToggleDetail>;'lr-rail-resize-request':CustomEvent<LyraAppRailResizeDetail>;'lr-rail-resize':CustomEvent<LyraAppRailResizeDetail>;}
/**
* `<lr-app-rail>` — a responsive navigation rail that adapts across three
* presentations as the *viewport* narrows (not this element's own inline
* size — see the `mode` getter doc for why): `'full'` (nav items show
* icon + label, inline), `'icon-only'` (a narrower inline rail, icons only),
* and `'mobile'` (hidden behind a toggle button; opening it shows a
* focus-trapped floating overlay over the page).
*
* Breakpoints are viewport-width `matchMedia()` queries against
* `icon-only-breakpoint`/`mobile-breakpoint`, not a `ResizeObserver` on this
* element — a nav rail's presentation should track the actual device/window
* width the way a native OS shell's navigation does, not however much
* horizontal space a particular layout happens to give it.
*
* The `'mobile'` state participates in the library's shared overlay stack,
* which supplies focus trapping, Escape/backdrop dismissal, inerting, and
* focus restoration without nesting a `<lr-dialog>` in this component's
* shadow template. `[part="base"]` (the inline
* `'full'`/`'icon-only'` presentation) and `[part="panel"]` (the mobile
* overlay) are the *same* element promoted in place across modes (mirrors
* `<lr-widget>`'s fullscreen mode) — never both at once, and never two
* separate copies of the slotted content, which slot projection can't
* produce anyway (a light-DOM node is only ever assigned to one `<slot>`).
* It's a plain `<div>` with an explicit `role="navigation"` rather than a
* literal `<nav>` tag: a `<nav>`'s implicit role can't be overridden to
* `role="dialog"` while the overlay is modal without an `aria-allowed-role`
* violation (verified against axe), whereas an explicit `role="navigation"`
* on a generic element can be swapped for `role="dialog"` freely.
*
* @customElement lr-app-rail
* @slot - Nav items. Use `<lr-app-rail-item>` for the explicit icon/label
*   contract that automatically hides labels in `'icon-only'` mode, and
*   `<lr-app-rail-group>` to title and optionally collapse a section of them --
*   a slotted group is marked `icon-only` exactly like a slotted item, and
*   forwards that state to the items it owns. Generic
*   links and buttons remain supported, but their compact presentation is the
*   consumer's responsibility. While the mobile overlay is open, clicking
*   anywhere inside this slot closes it.
* @slot header - Logo/brand content, shown above the nav items in every mode.
* @slot footer - A trailing user/settings trigger, shown below the nav items.
* @event lr-mode-change - The effective mode changed. A LIVE breakpoint crossing (after mount) or
*   an explicit `forceMode` assignment fires immediately, synchronously with the change. The mode
*   this component settles on for its very FIRST mount -- whether that is simply the initial
*   breakpoint match, or a persisted `preferred-mode` restored from storage (`storage-key` +
*   `persist="preferred-mode"`) overriding it -- instead fires once, from that same mount's first
*   `updated()`, so a listener always observes the single, settled mode once the initial render
*   and attribute reflection have both already landed, never an intermediate pre-restore value the
*   restore was always going to overwrite. Not fired for a redundant reassignment to the mode
*   already in effect, nor when the first mount's settled mode never left the constructor default
*   (the ordinary default-mode mount stays silent).
*   `detail: LyraAppRailModeChangeDetail`.
* @event lr-toggle - The mobile overlay is opening or closing — via the
*   built-in toggle button, Escape, a backdrop click, a nav-item click while
*   open, or a breakpoint/forced mode change leaving `'mobile'` while open.
*   Not fired when a consumer sets `open` directly (mirrors `<lr-dialog>`'s
*   `open`/`close()` split). `detail: LyraAppRailToggleDetail`. Conditionally cancelable: every
*   interactive trigger can be vetoed, but the forced mode-change close always applies
*   (vetoing it would leave `open` stuck `true` in a mode where it's
*   meaningless) -- call `preventDefault()` to keep the overlay as it is.
* @event lr-rail-resize-request - A cancelable request to change the `resizable` rail's width via
*   drag or keyboard stepping. Call `preventDefault()` to keep `railWidthPx` unchanged. Not fired
*   when a consumer sets `railWidthPx` directly. `detail: LyraAppRailResizeDetail`.
* @event lr-rail-resize - The `resizable` rail's width was committed: immediately after a genuine
*   keyboard step, or once on pointerup after a genuine drag. Non-cancelable; no event is emitted
*   for clamped no-ops, canceled/lost gestures, or direct `railWidthPx` writes.
*   `detail: LyraAppRailResizeDetail`.
* @csspart base - The rail root while inline (`'full'`/`'icon-only'` modes).
* @csspart header - The wrapper around the `header` slot.
* @csspart nav - The wrapper around the default (nav items) slot.
* @csspart footer - The wrapper around the `footer` slot.
* @csspart toggle - The mobile hamburger/close toggle button. Hidden via
*   CSS outside `'mobile'` mode, or -- while it is not also serving as the panel's only in-panel
*   dismiss control (see below) -- entirely via `hideToggle`; it inherits the rail's typography
*   and its glyph scales at 1em. Reparented to be the first child of `[part="panel"]` for exactly
*   as long as the mobile overlay is open, so the shared focus trap (scoped to the panel alone)
*   can reach it and Tab cycles through it like `<lr-dialog>`'s in-panel close button; moved back
*   to its resting position, a sibling ahead of `[part="panel"]`, once closed. Reparenting reuses
*   the same element throughout (never destroyed/recreated), so a reference captured before
*   opening remains valid after closing. Rendered as its own reserved row ahead of the `header`
*   slot while inside the panel, never absolutely overlaid on top of it, so a wide/slotted header
*   is never obscured. `hideToggle` only suppresses it in its OUTSIDE/closed position (the "open"
*   trigger, redundant once a consumer wires an external `trigger`/`for`); it stays visible once
*   reparented inside the open panel, since it is then the only in-panel dismiss control.
* @csspart backdrop - The mobile overlay's scrim. Only rendered while open.
* @csspart collapse-toggle - The opt-in desktop collapse control, rendered inside
*   `[part="header"]` only while `collapsible` is set and `mode` is not `'mobile'`. Carries the
*   localized expand/collapse accessible name and renders `aria-expanded` in both states, so a
*   screen reader announces the rail's current presentation rather than only its label.
*   `aria-expanded` is deliberate even though collapsing removes nothing from the accessibility
*   tree: `'icon-only'` only clips each item's `[part="label"]`/`[part="meta"]` visually, so a
*   screen-reader user reads the same nav either way, and the attribute is what tells a magnifier
*   or braille user which of the two presentations they are currently in. Its `aria-controls`
*   names `[part="nav"]` — the item list whose presentation actually changes — never the
*   `[part="base"]`/`[part="panel"]` element, which CONTAINS this button and would make the
*   control claim to expand its own ancestor.
* @csspart collapse-icon - The wrapper around `[part="collapse-toggle"]`'s chevron. The glyph is
*   direction-aware through this wrapper's own `transform` (never a second, mirrored icon), so it
*   always points toward the edge the rail is about to move to, under both `dir` values.
* @csspart panel - The mobile overlay's floating panel — see the class doc
*   for why it's the same element as `base`, never both at once.
* @csspart resizer - The `resizable` opt-in's drag handle -- its interactive hit target, sized to
*   the shared minimum tappable size (`--lr-icon-button-size`), independent of the slimmer
*   visible line rendered by its `resizer-track` child. Its numeric ARIA range remains in CSS
*   pixels while `aria-valuetext` reports the current width through the effective locale. Only
*   rendered while `resizable` and `mode` is `'full'`.
* @csspart resizer-track - The resizer's slim visible drag line, centered inside `[part="resizer"]`'s
*   larger hit target (mirrors `<lr-swatch-picker>`'s `[part="swatch"]`/`[part="swatch-fill"]`
*   split). Colors on hover/focus the same way the whole handle previously did.
* @cssprop [--lr-app-rail-width=var(--lr-size-15rem)] - The inline rail's width in `'full'` mode.
*   Overridden by an inline width while a `resizable` rail has an explicit `railWidthPx`.
* @cssprop [--lr-app-rail-icon-width=var(--lr-size-4rem)] - The inline rail's width in
*   `'icon-only'` mode, and the maximum width of each slotted `<lr-app-rail-item>` in that mode.
* @cssprop [--lr-app-rail-mobile-width=var(--lr-size-18rem)] - The mobile overlay panel's width,
*   capped at `85vw`.
* @cssprop [--lr-app-rail-overlay-color=var(--lr-color-overlay)] - The mobile overlay scrim's
*   background.
* @cssprop [--lr-app-rail-panel-inset-block-start=0] - Block-start (top) inset shared by
*   `[part="panel"]` and `[part="backdrop"]` -- raise it to leave room for a fixed app bar/status
*   area above the drawer instead of the panel/scrim starting flush with the viewport top.
* @cssprop [--lr-app-rail-panel-radius=0] - Uniform corner radius of `[part="panel"]`. `0` (the
*   default) reproduces today's flush-edged drawer; pairs naturally with a nonzero
*   `--lr-app-rail-panel-inset-block-start`, which exposes the panel's top corners. Each per-corner
*   token below defaults to this one, so setting only this token still rounds all four corners
*   uniformly, exactly as before the per-corner tokens existed.
* @cssprop [--lr-app-rail-panel-radius-start-start=var(--lr-app-rail-panel-radius)] - Logical
*   `border-start-start-radius` of `[part="panel"]` -- the corner at the drawer's own flush
*   inline-start edge, block-start side.
* @cssprop [--lr-app-rail-panel-radius-start-end=var(--lr-app-rail-panel-radius)] - Logical
*   `border-start-end-radius` of `[part="panel"]` -- the corner away from the flush inline-start
*   edge, block-start side. One of the two corners a flush-against-one-edge drawer typically
*   rounds.
* @cssprop [--lr-app-rail-panel-radius-end-start=var(--lr-app-rail-panel-radius)] - Logical
*   `border-end-start-radius` of `[part="panel"]` -- the corner at the drawer's own flush
*   inline-start edge, block-end side.
* @cssprop [--lr-app-rail-panel-radius-end-end=var(--lr-app-rail-panel-radius)] - Logical
*   `border-end-end-radius` of `[part="panel"]` -- the corner away from the flush inline-start
*   edge, block-end side. The other corner a flush-against-one-edge drawer typically rounds. All
*   four per-corner tokens are logical, so which physical corner each one paints swaps under
*   `dir="rtl"` with no second consumer rule -- the panel's own flush edge stays its logical
*   inline-start regardless of direction.
* @cssprop [--lr-app-rail-panel-overflow-block=auto] - `[part="panel"]`'s logical
*   `overflow-block`, paired with `--lr-app-rail-panel-overflow-inline` below.
* @cssprop [--lr-app-rail-panel-overflow-inline=clip] - `[part="panel"]`'s logical
*   `overflow-inline`. `clip` (the default) prevents a spurious horizontal scrollbar from wide
*   slotted header/footer content, but also clips a `position: fixed` popup opened by a
*   slotted/nav-item control (e.g. a slotted `<lr-select>`/`<lr-menu>`) whenever that popup's
*   rendered box extends past the panel's own inline bounds -- a `position: fixed` box is clipped
*   by an ancestor's non-`visible` overflow regardless of its own containing block. Setting only
*   this one to `visible` is not enough to escape that: per the CSS overflow spec, a lone
*   `visible` axis paired with a non-`visible` other axis computes as `auto` instead, which still
*   clips -- set `--lr-app-rail-panel-overflow-block` to `visible` too to actually stop the
*   clipping, accepting that wide header/footer content can then scroll/bleed both ways instead.
* @cssprop [--lr-app-rail-background=var(--lr-color-surface)] - `[part="base"]`'s background
*   (the docked, non-overlay presentation).
* @cssprop [--lr-app-rail-panel-background=var(--lr-color-surface-overlay)] - `[part="panel"]`'s
*   background (the mobile overlay presentation) -- kept separate from
*   `--lr-app-rail-background`/`--lr-app-rail-overlay-color` (the backdrop scrim) since the panel
*   is deliberately themed as a modal surface, not the docked rail chrome.
* @cssprop [--lr-app-rail-header-padding=var(--lr-space-m)] - `[part="header"]`'s padding.
* @cssprop [--lr-app-rail-footer-padding=var(--lr-space-m)] - `[part="footer"]`'s padding.
* @cssprop [--lr-app-rail-nav-padding=var(--lr-space-s)] - `[part="nav"]`'s padding, unset
*   reproducing the value this rule hard-coded before the token existed.
* @cssprop [--lr-app-rail-nav-gap=var(--lr-space-xs)] - Gap between slotted items inside
*   `[part="nav"]`, unset reproducing the value this rule hard-coded before the token existed.
* @cssprop [--lr-app-rail-header-min-block-size=auto] - `[part="header"]`'s minimum block size.
*   `auto` (the default) is the property's own initial value, so unset reproduces today's exact
*   height; set it to reserve room for header content that mounts or resizes asynchronously.
* @cssprop [--lr-app-rail-collapse-toggle-hover-bg=var(--lr-color-brand-quiet)] - Collapse-control
*   hover background.
* @cssprop [--lr-app-rail-collapse-toggle-hover-color=var(--lr-color-brand)] - Collapse-control
*   hover foreground.
* @cssprop --lr-app-rail-collapse-toggle-active-bg - Collapse-control pressed background; defaults
*   to the same brand-quiet active mix `[part="toggle"]` uses.
* @cssprop [--lr-app-rail-collapse-toggle-active-color=var(--lr-color-brand)] - Collapse-control
*   pressed foreground.
* @cssprop [--lr-app-rail-toggle-hover-bg=var(--lr-color-brand-quiet)] - Toggle hover background.
* @cssprop [--lr-app-rail-toggle-hover-color=var(--lr-color-brand)] - Toggle hover foreground.
* @cssprop --lr-app-rail-toggle-active-bg - Toggle pressed background; defaults to the former
*   brand-quiet active mix.
* @cssprop [--lr-app-rail-toggle-active-color=var(--lr-color-brand)] - Toggle pressed foreground.
* @cssprop [--lr-app-rail-resizer-hover-bg=var(--lr-color-brand)] - Resizer-track hover background.
* @cssprop --lr-app-rail-resizer-active-bg - Resizer-track pressed background; defaults to the
*   former brand active mix.
*
* @example
* Use the item contract so the visible label collapses while its accessible
* name remains available:
* ```html
* <lr-app-rail>
*   <lr-app-rail-item href="/inbox" aria-label="Inbox">
*     <svg slot="icon" aria-hidden="true">...</svg>Inbox
*   </lr-app-rail-item>
* </lr-app-rail>
* ```
* @status stable
* @since 4.0.0
*/
export declare class LyraAppRail extends LyraElement<LyraAppRailEventMap>{
/** Both are host state this component writes itself -- `mode` is the derived effective mode
*  (authors set `preferred-mode`), `dragging` tracks a live resize gesture. Neither is settable
*  from markup, so neither is observed; declaring them keeps the rail from reporting its own
*  output as an unknown attribute. */
protected static readonly knownUnobservedAttributes:readonly string[];static styles:import("lit").CSSResultGroup[];
/** Below this viewport width, the rail switches from `'full'` to
*  `'icon-only'`. Any valid CSS length, used directly in a `max-width`
*  media query. */
iconOnlyBreakpoint:string;
/** Below this viewport width, the rail switches from `'icon-only'` to
*  `'mobile'`. Should be smaller than `iconOnlyBreakpoint` to produce all
*  three states as the viewport narrows. */
mobileBreakpoint:string;
/** Whether the mobile floating overlay is shown. Only meaningful while
*  `mode` is `'mobile'`; leaving mobile mode closes it so a later mobile
*  transition never restores a stale modal. Set this directly, or use the built-in toggle button
*  — there is no separate `show()`/`hide()` pair.
*  @default false */
open:boolean;
/** Optional accessible name for the rail's navigation landmark and mobile dialog. Every
*  nonempty supplied string is literal; only absence/empty uses the localized fallback. A
*  host-level `aria-label` attribute takes precedence, including an explicit empty value. */
label?:string;
/** Accessible name overriding `label` (and its localized default) for the nav landmark / dialog
*  role, mirroring `<lr-date-input>`'s `accessibleLabel` pattern. Reads the host's own
*  `aria-label` attribute -- unset (the default, `null`) reproduces today's exact
*  `label`/localized-default output. */
private accessibleLabel;
/** Manually prefers `'full'` or `'icon-only'` for the non-mobile breakpoint axis, while the
*  `mobile-breakpoint` continues to be tracked automatically regardless — e.g. a user's manual
*  collapse toggle that should still yield to a genuinely too-narrow-for-any-inline-rail
*  viewport. Only consulted while `mode` isn't pinned via `forceMode` — that continues to take
*  full priority, unchanged. Unset (the default, `null`) reproduces today's exact
*  breakpoint-only behavior. */
preferredMode?:LyraAppRailPreferredMode|null;
/** Pins the rail's effective `mode` to `'full'` or `'icon-only'`, bypassing the live
*  `icon-only-breakpoint`/`mobile-breakpoint` match entirely. The sentinel `'auto'` (and the
*  unset default, `undefined`) release the pin and resume automatic breakpoint tracking --
*  whether the rail is currently pinned or auto-tracking is itself observable this way:
*  `forceMode === 'auto'` (or unset) means auto-tracking, any other value means pinned.
*  `'mobile'` cannot be pinned here -- the mobile breakpoint is always tracked automatically
*  regardless, mirroring `preferredMode`'s own scope. An unrecognized value is ignored, leaving
*  the current pinned/auto-tracking state unchanged. Applies synchronously -- mirrors the
*  pre-9.0 `mode` setter this replaced, including for code (a resize gesture's own pointermove
*  handler, e.g.) that reads `mode`-derived state immediately after assigning this property,
*  with no intervening render. `mode` itself is a read-only resolved accessor; assign
*  `forceMode` to change what it reports. */
get forceMode():LyraAppRailPreferredMode|'auto'|undefined;set forceMode(next:LyraAppRailPreferredMode|'auto'|null|undefined);private _forceMode?;
/** Suppresses the built-in mobile `[part='toggle']` hamburger/OPEN button -- for a consumer that
*  already owns an external mobile-menu trigger wired to this rail's own `open` property (see
*  `trigger`/`for`). `false` (the default) reproduces today's exact output; note `open` still
*  has no built-in external trigger of its own once this is set, since `lr-toggle` only fires
*  from the toggle button being removed. This does NOT remove the button once the overlay is
*  open: at that point it has been reparented inside the trapped `[part="panel"]` (see the
*  `toggle` csspart doc) as the panel's only in-panel dismiss control, and hiding it there too
*  would leave the open panel with no in-panel way to close it at all -- only Escape/backdrop. */
hideToggle:boolean;
/** Opts in the desktop collapse control: a `[part="collapse-toggle"]` button rendered inside
*  `[part="header"]` that flips the rail between its `'full'` and `'icon-only'` presentations,
*  the same flip `toggleCollapse()` performs. It writes `preferredMode`, so the collapse survives
*  a reload whenever `storage-key` is set and `persist` includes `preferred-mode`, and it still
*  yields to a viewport too narrow for any inline rail (see `preferredMode`'s own doc).
*
*  Not rendered at all while `mode` is `'mobile'` -- there is no inline rail to collapse there,
*  and rendering it would add a second, meaningless control to the focus-trapped overlay next to
*  the `[part="toggle"]` dismiss button. `false` (the default) reproduces today's exact output:
*  no extra element, and `[part="header"]`'s own block layout unchanged. */
collapsible:boolean;
/** Direct reference to an external element that opens this rail's mobile overlay -- e.g. a
*  hamburger button living in application chrome rather than this component's own built-in
*  `[part="toggle"]` (typically paired with `hideToggle`). When set (or resolved through
*  `for`), closing the overlay by ANY path -- Escape, backdrop click, a nav-item click, or the
*  built-in toggle itself -- returns focus to it, the same guarantee the built-in toggle's own
*  click already gets. An external trigger needs this explicit association instead of relying
*  on whatever last held focus: a consumer's own JS-driven `open = true` (rather than a real
*  click) never focuses anything, and even a real click does not reliably focus its target in
*  every browser. Resolved once when the overlay opens; reassign after that point to change the
*  return target for the overlay's remaining lifetime. Read alongside `for`; this direct
*  reference wins when both resolve to different elements. Unset (the default, `null`)
*  reproduces today's exact behavior: only the built-in toggle's own click supplies a return
*  target, for that interaction alone. */
trigger:HTMLElement|null;
/** Id of an external element that opens this rail's mobile overlay, the label/`htmlFor`-style
*  alternative to assigning `trigger` directly -- mirrors `<lr-page-rail>`'s `for`. Resolved
*  against this element's own root (shadow root or document) when the overlay opens. Ignored
*  once `trigger` is itself set. */
for:string;
/** Opts a continuously draggable width in for the `'full'` state — exposes a `[part="resizer"]`
*  handle (pointer-drag and `ArrowLeft`/`ArrowRight` keyboard stepping, RTL-aware) clamped to
*  `[minRailWidthPx, maxRailWidthPx]`. Set `storageKey` to persist the fields selected by
*  `persist`; otherwise listen for `lr-rail-resize` and persist its committed `widthPx` yourself.
*  Call `preventDefault()` on `lr-rail-resize-request` to keep the current width. A request
*  listener that disables resizing, leaves full mode, or disconnects the rail also cancels the
*  pending proposal without overwriting listener state. `false` (the
*  default) renders no resizer and leaves the fixed-width `--lr-app-rail-width` CSS token exactly
*  as before this property existed. */
resizable:boolean;
/** When set, persists the fields selected by `persist` to `localStorage` under
*  `lr-app-rail:${storageKey}`, restoring them on the next mount — mirrors `lr-multi-split`'s
*  `storage-key`. Effective `mode` is breakpoint-derived and is never persisted, and a stored
*  `open` is restored only onto a mount whose breakpoint-derived mode is already `'mobile'` —
*  `open` means nothing at a wider breakpoint (see its own doc), so a stored one is dropped
*  there rather than left primed to throw the overlay open the moment the viewport narrows.
*  Unset (the default) means no persistence, exactly as before. */
storageKey?:string;
/**
* Whitespace-separated persistence allowlist. `open width` is the backward-compatible default;
* use `width preferred-mode` to retain layout preference without restoring the transient mobile
* overlay. Valid tokens are `open`, `width`, and `preferred-mode`.
*/
persist:string;
/** The rail's current width in px while `resizable` — settable/gettable. Unset defers to the
*  `--lr-app-rail-width` CSS token's own resolved width. */
railWidthPx?:number;
/** Minimum `railWidthPx` a drag/keyboard resize can reach. */
minRailWidthPx:number;
/** Maximum `railWidthPx` a drag/keyboard resize can reach. */
maxRailWidthPx:number;
/** `true` for the duration of an active pointer-driven resize drag (not a keyboard step) --
*  reflected so a consumer (or this component's own styles) can suppress `[part='base']`'s
*  `transition: inline-size` during the drag, which otherwise visibly "chases" the pointer
*  instead of tracking it 1:1. Read-only -- this component owns the transitions entirely; there
*  is no public setter. */
get dragging():boolean;private _dragging;
/** Sets `_dragging` and its reflected `[dragging]` attribute together. `dragging` has no
*  template binding of its own (only the CSS selectors in `app-rail.styles.ts` key off the
*  attribute), so this bypasses Lit's reactive-property machinery entirely rather than routing
*  through `requestUpdate()` -- see the `dragging` getter doc for why there is no public
*  setter. */
private setDragging;private hasHeaderSlot;private hasFooterSlot;
/** False until after the first `updated()`, so persistence never fires on the load pass. */
private persistReady;private _mode;private _lastReflectedMode?;private pendingInitialModeAnnouncement?;private forced;private iconOnlyMatches;private mobileMatches;private mqIconOnly?;private mqMobile?;private mqIconOnlyListener?;private mqMobileListener?;private overlayActive;private justOpened;private overlayHandle?;private explicitTrigger?;private triggerAria?;private recoverInlineFocusAfterResponsiveClose;private readonly navId;
/** `[part="nav"]`'s own id, distinct from `navId`. `[part="collapse-toggle"]` lives inside the
*  element carrying `navId`, so pointing its `aria-controls` there claimed the button expands its
*  own ancestor; the item list it actually re-presents is `[part="nav"]`. */
private readonly navRegionId;private baseEl?;private toggleEl?;private resizePointerId?;private resizeOwnerWindow?;private resizeStartX;private resizeStartWidth;private resizeGestureChanged;private managedItems;private syncSlottedItems;
/**
* The rail's current effective presentation. Always one of the three real
* modes — never `'auto'` — reflecting either the live breakpoint match or,
* once pinned via `forceMode`, whatever mode is currently pinned.
*
* Read-only: this getter never accepts an assignment. Set `forceMode` to
* pin `'full'`/`'icon-only'`, or to `'auto'`/unset to release the pin and
* resume automatic breakpoint tracking -- unlike the pre-9.0 `mode`
* setter this replaced, whether the rail is currently pinned is itself
* observable via `forceMode === 'auto'` (or unset).
*
* Reflected to the `mode` attribute for `:host([mode="..."])` styling --
* manually, via `updated()`, since this property has no Lit-managed
* accessor to reflect through (see `setEffectiveMode()`).
*/
get mode():LyraAppRailMode;
/** `minRailWidthPx` normalized to a finite, non-negative px floor -- an invalid attribute value
*  would otherwise poison every `Math.min(maxRailWidthPx, Math.max(minRailWidthPx, ...))` clamp
*  below (both the drag and keyboard-step handlers) and the resizer's own `aria-valuemin`. */
private get safeMinRailWidthPx();
/** `maxRailWidthPx` normalized the same way, then cross-referenced against the already-sanitized
*  minimum so an inverted/invalid pair (e.g. `maxRailWidthPx` left below a since-raised
*  `minRailWidthPx`) can never produce a negative-width clamp range. */
private get safeMaxRailWidthPx();
/** The rail's current effective width in px, whether or not `railWidthPx` has ever been
*  explicitly set — falls back to the live measured width of `[part=base]` so the resizer's
*  `aria-valuenow` and the first drag/keyboard step's start-width reflect the real rendered
*  width even before a consumer ever sets `railWidthPx`. A set `railWidthPx` is clamped into
*  `[safeMinRailWidthPx, safeMaxRailWidthPx]` here -- a NaN/negative/out-of-bounds direct
*  assignment would otherwise reach `updated()`'s inline-size write and this resizer's own
*  `aria-valuenow` exactly as given. */
private get effectiveRailWidthPx();private resizeValueText;private get storageFullKey();private get persistFields();
/** Restore the selected persisted fields. Runs once, before the first render, and never
*  overwrites a field the consumer already assigned before this point -- a controlled
*  `.open=${false}`/`.railWidthPx=${240}` binding stays authoritative over stale `localStorage`
*  state instead of being silently clobbered by it, with no `lr-toggle` (or equivalent) firing
*  for a change the consumer never asked for. Effective `mode` remains breakpoint-derived; only
*  the optional non-mobile `preferredMode` input is restorable.
*
*  The per-field guard is `isPersistedPropertyExplicitlySet()`, which reports whether the
*  property's setter ever ran. The `changed.has(...)` check it replaces could not answer that
*  for `open`: Lit enters a property carrying a declared default into the very first
*  `changedProperties` batch on its own, so the guard was true on every mount and the restore
*  never ran at all.
*
*  Reports which fields this pass actually wrote (never which ones storage merely held), so
*  `willUpdate()` can post-process exactly those: fold a restored `preferredMode` into the
*  first render's effective mode, and drop a restored `open` the settled mode cannot support. */
private loadPersisted;private persistState;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;
/** Resolves the settable external open trigger -- a direct `trigger` reference, or the element
*  `for` idrefs, in that order. `null` when neither is set or `for` doesn't resolve to a real
*  element, in which case `activateMobileOverlay()`'s own fallback (whatever held focus when
*  the overlay opened -- e.g. the built-in toggle after its own click) continues to apply
*  exactly as before either property existed. */
private resolveExternalTrigger;private activateMobileOverlay;private deactivateMobileOverlay;
/** Reparents the (never destroyed/recreated) toggle button between its two valid DOM positions:
*  the first child of `[part="panel"]` while the mobile overlay is open, so the shared focus
*  trap and `aria-modal` subtree (both scoped to the panel alone) actually reach it, or a
*  sibling immediately ahead of `[part="base"]`/`[part="panel"]` -- its resting position --
*  otherwise. Called BEFORE `activateMobileOverlay()`/`deactivateMobileOverlay()` from
*  `willUpdate()` so the move (in either direction) always lands before that same pass's render
*  applies `[part="panel"]`'s `inert` attribute: moving the focused toggle out first, ahead of
*  `inert` landing on its old parent, is what lets `deactivateMobileOverlay()`'s focus-return
*  land and stick instead of the browser force-blurring it a moment later for having become a
*  descendant of a newly-inert ancestor. Also called from `updated()` as an idempotent
*  post-render catch-up, since this component's own `@query` refs are not yet resolvable before
*  the very first render -- needed for a rail that mounts directly into an already-open mobile
*  overlay. Each branch checks the toggle's current position and skips the DOM write entirely
*  when it is already where it belongs -- NOT merely as an optimization: `Node.insertBefore()`
*  unconditionally removes the node from its current parent before re-inserting it, even when
*  the requested position is exactly where the node already is, and removing the currently
*  *focused* element -- even for a single synchronous remove-then-reinsert with no yield to the
*  browser -- silently drops focus. `updated()`'s post-render catch-up call runs immediately
*  after `deactivateMobileOverlay()`'s own focus-return inside the same `willUpdate()`/render
*  pass, so an unconditional `insertBefore()` there would re-blur the toggle right after focus
*  had just been restored to it. Observed for real: before this guard, "returns focus to the
*  toggle button after closing" failed only once `placeToggle()`'s close-direction move itself
*  started working (see the `parentNode`/`parentElement` note above) -- while that move was
*  silently a no-op, this redundant call was too, which is why the loss went unnoticed. */
private placeToggle;private setupMediaQueries;private teardownMediaQueries;private onIconOnlyChange;private onMobileChange;private applyComputedMode;private setEffectiveMode;private setOpen;private onToggleClick;private onBackdropClick;
/**
* Flips the rail between its `'full'` and `'icon-only'` presentations by writing
* `preferredMode` -- the same action `[part="collapse-toggle"]` performs, exposed for a consumer
* that renders its own collapse control (in app chrome, a command palette, a keyboard shortcut)
* instead of, or alongside, opting into `collapsible`.
*
* Writes `preferredMode`, never `forceMode`: the collapse is a *preference* on the
* full/icon-only axis, so the `mobile-breakpoint` keeps being tracked automatically and a
* genuinely too-narrow viewport still wins. It therefore persists exactly like any other
* `preferredMode` write -- whenever `storage-key` is set and `persist` includes
* `preferred-mode` -- and announces itself through the existing `lr-mode-change` event.
*
* A no-op while `mode` is `'mobile'`: there is no inline rail to collapse, and flipping the
* preference from there would silently arm a presentation the user never chose for whenever the
* viewport widened again. While `forceMode` pins the mode the preference is still recorded, and
* takes effect the moment the pin is released -- `preferredMode`'s own documented priority.
*/
toggleCollapse():void;private onCollapseToggleClick;
/** Projects the disclosure state of the mobile overlay onto whatever external element
*  `trigger`/`for` resolves to, through the shared ARIA-ownership lease `<lr-popover>` uses for
*  the same job. An external trigger lives in the consumer's light DOM while `[part="panel"]`
*  lives in this shadow root, so a plain `aria-controls` idref cannot connect them -- the lease
*  falls back to the `ariaControlsElements` element-reference form, which crosses the boundary,
*  and restores whatever the consumer had written itself once released.
*
*  Applied only while `mode` is `'mobile'`. Outside it there is no overlay for the trigger to
*  expand, and a permanent `aria-expanded="false"` on a control that can never expand anything
*  announces a disclosure that does not exist. Unlike the focus-return association (resolved
*  once, when the overlay opens), this tracks live: reassigning `trigger` moves the state to the
*  new element and clears it from the old one on the next update. */
private syncExternalTriggerA11y;private releaseExternalTriggerA11y;private onNavItemClick;private onHeaderSlotChange;private onFooterSlotChange;private onNavSlotChange;private onResizerPointerDown;private onResizerPointerMove;private onResizerPointerUp;private endResizerGesture;
/** Emits the cancelable proposal before committing, so a vetoed gesture never mutates width or
*  triggers the existing post-commit resize notification. */
private requestRailResize;private onResizerKeyDown;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-app-rail':LyraAppRail;}}