import type{LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import{type TemplateResult,type PropertyDeclaration,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import{type BreakpointBasis}from'../../../internal/orientation-breakpoint.js';import type{LyraOrientation}from'../../../internal/shared-unions.js';
/** A fixed-pixel-range constraint for one panel; index-aligned with `sizes`/
*  `panelConstraints`. Either bound may be omitted to leave that side
*  unconstrained (falls back to the component's percent-based `min`). */
export interface LyraMultiSplitPanelConstraint{readonly minPx?:number;readonly maxPx?:number;readonly minPercent?:number;readonly maxPercent?:number;}export type LyraMultiSplitConstraintIssueReason='minimum-total'|'maximum-total'|'minimum-exceeds-maximum';export interface LyraMultiSplitConstraintIssueDetail{readonly reason:LyraMultiSplitConstraintIssueReason;readonly panelCount:number;readonly minimumTotal:number;readonly maximumTotal:number|null;readonly containerSize:number;}
/** Which pane (if any) participates in responsive collapse (see `collapse`). */
export type LyraMultiSplitCollapseMode='start'|'end'|'none';
/** The collapsing pane's current responsive state — `'wide'` is the normal
*  drag-resizable percent layout (identical to `collapse="none"`); `'rail'`
*  clamps it to `railWidth`; `'floating'` lifts it out of the flex flow as an
*  overlay above the other pane. */
export type LyraMultiSplitCollapseState='wide'|'rail'|'floating';
/** What can be *assigned* to `collapseState` -- `'auto'` is a write-only
*  sentinel; see the `collapseState` accessor doc. */
export type LyraMultiSplitCollapseStateInput=LyraMultiSplitCollapseState|'auto';export interface LyraMultiSplitCollapseChangeDetail{readonly state:LyraMultiSplitCollapseState;}export interface LyraMultiSplitToggleDetail{readonly open:boolean;}export interface LyraMultiSplitResizeDetail{readonly sizes:readonly number[];}export interface LyraMultiSplitOrientationChangeDetail{readonly orientation:LyraOrientation;}export interface LyraMultiSplitEventMap{'lr-resize-request':CustomEvent<LyraEventDetailSnapshot<LyraMultiSplitResizeDetail>>;'lr-resize':CustomEvent<LyraEventDetailSnapshot<LyraMultiSplitResizeDetail>>;'lr-multi-split-collapse-change':CustomEvent<LyraMultiSplitCollapseChangeDetail>;'lr-toggle':CustomEvent<LyraMultiSplitToggleDetail>;'lr-multi-split-constraints-invalid':CustomEvent<LyraMultiSplitConstraintIssueDetail>;'lr-multi-split-orientation-change':CustomEvent<LyraMultiSplitOrientationChangeDetail>;}
/**
* `<lr-multi-split>` — resizable panels for dashboard layouts. Direct light-DOM
* children are the panels; a divider is auto-inserted between each pair. Give every panel a
* unique, nonempty, whitespace-stable `panel-id` when using `storageKey`: persistence records `panelId`/size pairs,
* so reordered or replaced panels recover the size belonging to their business identity instead
* of whichever panel happens to occupy the old array index. Missing or duplicate identities fail
* persistence closed while leaving the live, non-persisted split usable.
* In a fixed block allocation, each direct panel is a scroll container
* (`min-block-size: 0; overflow: auto`) so long content stays within the
* split instead of escaping into following content. Set an individual
* panel's own `overflow` when it needs a different scrolling surface.
*
* Optionally, one pane can opt in to responsive collapse via `collapse`
* (`"start"`/`"end"`, default `"none"` — no behavior change when unset): as
* the split's own container narrows past `railBreakpoint` that pane clamps
* to a fixed `railWidth`, and past the narrower `floatBreakpoint` it instead
* becomes an absolutely-positioned overlay "floating card" above the other
* pane. Both breakpoints accept a bare pixel number or a CSS length
* (`px`/`rem`/`em`), and `collapseBreakpointBasis="viewport"` measures them
* against the viewport via `matchMedia` instead of this component's own
* allocation. This component only handles the width-collapse mechanics and
* signals the current state — via the `collapseState`-derived
* `data-collapse-state` attribute (set on both the host and the collapsing
* panel itself) and the `lr-multi-split-collapse-change` event — it renders no
* icon-only/collapsed UI of its own; slotted content is expected to adapt to
* its own clamped width (e.g. via its own container query).
*
* `collapseState` is a public accessor with force/auto semantics mirroring
* `<lr-app-rail>`'s `mode`: it's normally derived automatically from the
* measured container width (via a `ResizeObserver` on `[part="base"]`)
* whenever it crosses `railBreakpoint`/`floatBreakpoint`, but assigning it a
* concrete `'wide'`/`'rail'`/`'floating'` value pins it there and stops that
* automatic tracking — useful for a consumer-driven toggle (e.g. a button
* that forces `'floating'` regardless of width). Assigning the write-only
* `'auto'` sentinel releases the pin and immediately re-derives the state
* from the current measured width, resuming automatic tracking. `'auto'` is
* never a value this getter returns. `expandPane()`/`collapsePane()`/`togglePane()` drive the
* same two mechanisms semantically -- each picks the drawer or the pin according to the pane's
* current band, so a consumer-built trigger no longer has to branch on `collapseState`
* itself -- and `releasePinOnBreakpoint` opts a pin in to releasing itself when the band or
* the effective orientation moves on, instead of leaking into the next layout.
* While `collapse="none"` or fewer than two direct panels exist, the public
* and reflected effective state is always `'wide'`: a forced rail/floating
* intent is retained privately for a later eligible pane but cannot emit,
* render a backdrop, acquire focus/scroll-lock ownership, or project panel
* markers. Enabling/disabling an eligible pane is itself an effective state
* transition; disabling closes `open` and releases overlay/focus ownership.
*
* The `'floating'` state is a hidden-by-default drawer, gated by `open`
* (mirrors `<lr-app-rail>`'s mobile overlay): while `collapseState` is
* `'floating'` and `open` is `false` (the default), the collapsing panel
* renders nothing — `hidden`, out of the accessibility tree, not just
* visually hidden — instead of the always-visible overlay card this state
* rendered before `open` existed. Setting `open = true` reveals it as a
* focus-trapped floating panel with a `[part="backdrop"]` scrim; Escape or a
* backdrop click proposes a cancelable close before changing `open`. Every sibling pane behind the drawer is inert for the
* same interval, while the floating pane is the shared overlay manager's modal root. `open` is preserved (not reset)
* while `collapseState` isn't `'floating'`, but no drawer chrome renders
* until it is again — except that leaving `'floating'` while `open` is
* `true` (a breakpoint crossing back to `'wide'`/`'rail'`, or a forced
* reassignment) also closes it, the same way `<lr-app-rail>` closes its
* mobile overlay when leaving `'mobile'` while open.
*
* Public collection properties take bounded, clone-owned readonly snapshots. Create a new
* collection and reassign it after changes; mutating the assigned array does not update the view.
*
* @customElement lr-multi-split
* @event lr-resize-request - A cancelable proposed `sizes` change from a divider drag or keyboard
*   step. Call `preventDefault()` to keep `sizes` and persistence unchanged. Not fired when a
*   consumer sets `sizes` directly. `detail: { sizes }` (`LyraMultiSplitResizeDetail`).
* @event lr-resize - `detail: { sizes }`, fired on every drag movement that changes sizes and every
*   keyboard step after `sizes` is assigned. Non-cancelable; not fired when a consumer sets
*   `sizes` directly. Pointer release persists the settled sizes but emits no additional event.
* @event lr-multi-split-collapse-change - `detail: { state }` (`LyraMultiSplitCollapseChangeDetail`),
*   fired whenever the responsive `collapseState` actually transitions between
*   `'wide'`/`'rail'`/`'floating'` — whether from a breakpoint crossing or an
*   explicit `collapseState` assignment or collapse feature enable/disable.
*   Fired AFTER the collapsing panel is decorated for the new state: its
*   `data-collapse-state` marker, the `hidden` flag of the closed drawer and
*   its owned inline sizing are all applied first, so a listener can read the
*   panel synchronously inside its own handler instead of deferring past
*   `updateComplete`. Focus is also moved out of a pane the new state hides or
*   clamps before the event fires.
*   Forced writes while no eligible collapsing pane exists are inert and do
*   not fire. Not fired for a redundant reassignment to the state already in
*   effect.
* @event lr-toggle - An Escape/backdrop request to close the floating drawer, or the forced close
*   when an effective collapse transition leaves `'floating'` while open. `detail:
*   LyraMultiSplitToggleDetail`. Escape/backdrop proposals are cancelable and fire before `open`
*   changes; the forced responsive close is non-cancelable and fires after `open` is false. Direct
*   `open` writes and no-op dismissals do not emit this event.
* @event lr-multi-split-constraints-invalid - `detail: LyraMultiSplitConstraintIssueDetail`,
*   fired once when the configured panel minimums/maximums cannot describe a
*   layout that fits the track. The splitter rejects that infeasible set for
*   interaction and falls back to a normalized percent minimum.
* @event lr-multi-split-orientation-change - `detail: { orientation }`, fired when an enabled
*   `orientationBreakpoint` changes the effective resize/layout axis.
* @slot - Panels to arrange side by side (or stacked, when `orientation="vertical"`); each direct child becomes one resizable panel. Set a unique nonempty, whitespace-stable `panel-id` on every panel when using persistence.
* @csspart base - The flex layout wrapper (`position: relative`, so the `'floating'` collapse state can anchor to it).
* @csspart divider - Each `role="separator"` between two panels. `aria-valuenow` is the leading
*   panel's percentage; `aria-valuemin`/`aria-valuemax` are that divider's currently achievable
*   range, bounded by both adjacent panels' effective constraints and their current combined
*   share (not whole-track bounds). Home/End move directly to those achievable extremes. Carries
*   `aria-disabled="true"` and is drag/keyboard-inert
*   while its adjacent panel is collapsed (`'rail'`/`'floating'`).
* @csspart backdrop - The `'floating'` drawer's scrim. Only rendered while `collapseState === 'floating'` and `open`.
* @cssprop [--lr-multi-split-overlay-color=var(--lr-color-overlay)] - The `'floating'` drawer scrim's color, applied to `[part="backdrop"]`.
* @cssprop [--lr-multi-split-divider-target-size=max(var(--lr-icon-button-size),var(--lr-size-3px))] -
*   The real layout gutter reserved for each divider along the resize axis. The narrow visual rule
*   is centered inside this owned track, so the target never overlaps either adjacent panel.
* @cssprop [--lr-multi-split-divider-thickness=var(--lr-size-3px)] - The painted hairline's own
*   thickness, independent of `--lr-multi-split-divider-target-size` above -- retuning either one
*   never changes the other, so the WCAG 2.5.8 pointer target can never be shrunk by a thinner or
*   thicker visual line.
* @cssprop [--lr-multi-split-divider-color=var(--lr-color-border)] - The divider hairline's
*   resting color.
* @cssprop [--lr-multi-split-divider-hover-color=var(--lr-color-brand)] - The divider hairline's
*   color on hover.
* @cssprop [--lr-multi-split-divider-active-color=color-mix(in oklab,var(--lr-color-brand),var(--lr-color-mix-partner) var(--lr-color-mix-active))] -
*   The divider hairline's color while a resize gesture is pressed (pointer capture holds this
*   through the whole drag).
* @cssprop [--lr-multi-split-floating-panel-inset=0] - The `'floating'` drawer's distance from
*   `[part="base"]`'s edges, applied to both block insets and to whichever logical inline edge
*   `collapse` anchors the drawer to. Unset, the drawer stays flush with the container exactly as
*   before; set once, it insets on all three anchored edges (the free inline edge stays governed
*   by the panel's own width).
* @cssprop --lr-multi-split-floating-panel-inline-size - Overrides the `'floating'` collapse
*   state's overlay card `inline-size`, which otherwise mirrors its own live `sizes[i]` percent
*   (i.e. what it renders at in the `'wide'` state). Unset, geometry is identical to today's
*   behavior; set, it wins over that percent without needing `!important` against the
*   live-synced inline style.
* @status stable
* @since 9.0.0
*/
export declare class LyraMultiSplit extends LyraElement<LyraMultiSplitEventMap>{protected static readonly ownedCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];private toggleProposalDepth;private toggleProposalMutationVersion;private forcedCloseVersion;protected static readonly immutableEventDetails:readonly string[];static properties:{collapseState:{reflect:boolean;attribute:string;noAccessor:boolean;};};sizes:readonly number[];
/** Initialization-only size fallback, below valid persistence and above equal distribution. Later
*  assignments never overwrite live resize state. Each entry is either a plain number (percent of
*  the container, matching today's exact strict behavior) or a CSS length string (`'200px'`,
*  `'20%'`, `'3rem'`) resolved against the measured container before percent-space validation --
*  see `resolveDefaultSizes()`. Initialization runs on the first update (not synchronously on
*  connection), so same-turn framework property bindings and `storageKey` persistence participate
*  before the layout becomes live. A pure-number array is validated unchanged (an array that does
*  not sum to ~100 is still rejected). */
defaultSizes:readonly(number|string)[];min:number;orientation:LyraOrientation;
/** Opt-in inline-size breakpoint for this component's *own* measured allocation. Below it,
*  `narrowOrientation` becomes effective. Unset by default — the whole responsive-orientation
*  feature (and its `ResizeObserver`) is off, and `effectiveOrientation` just tracks
*  `orientation`.
*
*  Accepts a bare pixel number (`900`, `orientation-breakpoint="900"` — the original form) or a
*  CSS length string: `'900px'`, `'56.25rem'`, `'3em'`. Under the default
*  `orientationBreakpointBasis="container"`, `rem` resolves against the *document root*'s
*  computed font size — the rule a `@container` query follows, not a `@media` query's — and `em`
*  against this element's own computed font size. The length is re-resolved on every measurement,
*  never cached at first render, so a root font-size change moves the crossing width with no
*  invalidation step. To stay in step with a sibling `@media (max-width: 56.25rem)` rule, use
*  `orientationBreakpointBasis="viewport"`, which hands the length to the browser instead; see
*  that property for why the two resolve `rem` differently.
*
*  Anything else — `''`, `'auto'`, garbage, a non-finite number, and deliberately `%`/`vw`/`vh`/
*  `calc()` (which would mix reference boxes against an element-relative measurement) — behaves
*  exactly as unset. Set `orientationBreakpointBasis="viewport"` for a viewport-relative
*  breakpoint instead. */
orientationBreakpoint?:number|string;
/** Which box `orientationBreakpoint` measures. `'container'` (the default) observes this
*  component's own `[part="base"]` inline size via `ResizeObserver`, comparing strictly `<`.
*  `'viewport'` instead evaluates `matchMedia('(max-width: <breakpoint>)')`, which is inclusive
*  (`<=`) — native `max-width` semantics, deliberately, so the crossing point matches a CSS
*  `@media` rule authored with the same length exactly.
*
*  Use `'viewport'` when two siblings in one row must flip together at a shared breakpoint: a row
*  that stacks via a pure-CSS `@media` rule makes each sibling's own width non-monotonic across
*  the transition, so no self-measured threshold can express it. `'viewport'` also lets the
*  browser resolve a `rem` breakpoint with real `@media` semantics, keeping it in step with such
*  a rule across browser zoom and user font-size preferences. */
orientationBreakpointBasis:BreakpointBasis;
/** Layout/resize axis used below `orientationBreakpoint`. */
narrowOrientation:LyraOrientation;
/** When set, this instance's panel sizes are persisted to `localStorage`, keyed by this value
*  plus each panel's identity (`panel-id`, falling back to DOM order), and restored on the next
*  mount. Initialization-time precedence, highest first: an already-valid `sizes` binding (an
*  explicit authored layout for THIS mount always wins and is never silently replaced), then a
*  valid persisted layout, then `defaultSizes`, then equal distribution. Restoring persisted
*  state never fires an event -- read `sizes` after the component's first update to observe it. */
storageKey?:string;
/** Optional px and/or percent min/max per panel, index-aligned with `sizes`. A
*  `null`/missing entry leaves that panel purely percent-based (the
*  existing `min`-only behavior). `sizes`, the `lr-resize` payload, and
*  localStorage persistence stay percent-based regardless — only the
*  effective clamp bounds change for a constrained panel. Feasible pixel minimums survive flex
*  shrink after divider gutters. When those floors cannot fit, panels share the remaining space
*  proportionally instead of overflowing; percentage state remains unchanged. Gutter geometry
*  follows the actual divider, including live font-unit and token changes. */
panelConstraints:readonly(LyraMultiSplitPanelConstraint|null)[];
/** Opts a pane in to responsive collapse: `'start'` is the first light-DOM
*  panel (index 0), `'end'` is the last. Both are LOGICAL positions, same
*  as CSS `inset-inline-start`/`-end` — see the `collapsingIndex` getter
*  for why that already resolves to the same physical index under RTL for
*  this component (panels are never re-`order`ed for RTL, only the drag
*  delta sign mirrors). Default `'none'`: none of the collapse behavior
*  below applies, and rendering/behavior is identical to before this
*  property existed. */
collapse:LyraMultiSplitCollapseMode;
/** Fixed CSS length the collapsing pane clamps to in the `'rail'` state. */
railWidth:string;
/** Width below which the collapsing pane switches from its normal percent width to the fixed
*  `railWidth` (`'rail'` state). Must stay above `floatBreakpoint` — an inverted pair is
*  sanitized by raising this one to match, which collapses the `'rail'` band away rather than
*  leaving a wide container reported as collapsed.
*
*  Accepts a bare pixel number (`640`, `rail-breakpoint="640"` — the original form) or a CSS
*  length string: `'640px'`, `'68.75rem'`, `'3em'`. Under the default
*  `collapseBreakpointBasis="container"` this is compared against this component's own measured
*  `[part="base"]` inline size, strictly `<`, and `rem` resolves against the *document root*'s
*  computed font size (a `@container` query's rule, not a `@media` query's) while `em` resolves
*  against this element's own. The length is re-resolved on every measurement, never cached, so
*  a root font-size change moves the crossing width with no invalidation step.
*
*  Anything the grammar rejects — `''`, `'auto'`, garbage, a non-finite number, and deliberately
*  `%`/`vw`/`vh`/`calc()`/`var()` — falls back to the `640` default rather than switching the
*  feature off (unlike `orientationBreakpoint`, this breakpoint has a documented default to fall
*  back to). A negative length is floored at `0`, i.e. never crossed.
*
*  Default: `640`. */
railBreakpoint:number|string;
/** Width below which the collapsing pane instead becomes an absolutely-positioned overlay above
*  the other pane (`'floating'` state). Same accepted forms, basis, and sanitization as
*  `railBreakpoint`; an unparseable value falls back to the `400` default.
*
*  Default: `400`. */
floatBreakpoint:number|string;
/** Which box `railBreakpoint`/`floatBreakpoint` measure. `'container'` (the default) observes
*  this component's own `[part="base"]` inline size via `ResizeObserver`, comparing strictly `<`.
*  `'viewport'` instead evaluates `matchMedia('(max-width: <breakpoint>)')` for each of the two
*  thresholds, which is inclusive (`<=`) — native `max-width` semantics, deliberately, so the
*  crossing point matches a CSS `@media` rule authored with the same length exactly. Switching
*  basis therefore shifts each crossing point by 1px (the same trade-off
*  `orientationBreakpointBasis` already makes).
*
*  Use `'viewport'` to collapse in step with a page-level responsive layout — e.g. a shell whose
*  own `@media` rules restack at the same width — rather than with this split's own allocation.
*  `'viewport'` also lets the browser resolve a `rem` breakpoint with real `@media` semantics
*  (against the *initial* font size, ignoring an `html { font-size }` override), keeping it in
*  step with such a rule.
*
*  Both bands are classified from both queries together on every change, so a fast resize that
*  crosses both thresholds at once still lands on one correct state and fires
*  `lr-multi-split-collapse-change` once. Under `'viewport'` basis the first paint is already correct —
*  no `ResizeObserver` round-trip — and the initial state is not announced as a transition.
*
*  Default: `'container'`. */
collapseBreakpointBasis:BreakpointBasis;
/** Opts a pinned `collapseState` (see that accessor's force/auto contract) in to releasing
*  itself when the layout it was made for is gone: either the measured collapse band changes to
*  a different one than the pin was created in, or `effectiveOrientation` crosses
*  `orientationBreakpoint`. The pin is dropped exactly as if `'auto'` had been assigned, and the
*  state re-derives from the current measurement, firing `lr-multi-split-collapse-change` if that
*  is an actual transition.
*
*  Default `false`, which is the pre-existing behavior: a pin survives every band and orientation
*  change until a consumer assigns `'auto'`. Opt in when a pin is meant for one layout only --
*  e.g. a rail pinned for a wide dashboard that must not leak into the narrow, drawer-based
*  layout, which otherwise has to be undone by hand from an `lr-multi-split-collapse-change` or
*  `lr-multi-split-orientation-change` listener. Re-measuring the SAME band never releases a
*  pin, so an ordinary resize inside one band leaves it alone. */
releasePinOnBreakpoint:boolean;
/** Whether the `'floating'` collapse state's drawer is shown. Only
*  meaningful while `collapseState` is `'floating'` — the value is
*  preserved (not reset) while another state is active, but no drawer
*  chrome renders until `collapseState` is `'floating'` again. Defaults to
*  `false`: the collapsing pane renders nothing while floating until a
*  consumer opts in by setting this (or it's forced open programmatically)
*  — see the class doc. */
open:boolean;
/** Overrides the auto-inserted divider's `aria-label` — receives the divider's 0-based index
*  and the total panel count (`lr-multi-split` supports N panels, so a single fixed string can't
*  express every divider's label; a function can). Unset (the default) keeps today's exact
*  localized `Resize divider between panel {a} and panel {b}` template (see `this.localize()`). */
dividerLabel?:(index:number,panelCount:number)=>string;
/** Internal hydration seed reflected into declarative output so a property-driven server render
* and the browser's first reuse pass agree before assigned children can be observed. */
private panelCount;private sizesReconciledForMembership;private _collapseState;private _forced;private pinnedBand?;private overlayActive;private justOpened;private overlayHandle?;
/** The panel `role`/`aria-modal` were last overwritten on and their prior values, so closing the
*  drawer restores exactly what the consumer had authored rather than assuming it was unset. */
private floatingDialogPanel;private floatingDialogPreviousRole;private floatingDialogPreviousAriaModal;private drags;private dragOwnerWindow?;private ownedPanels;private readonly panelOwnership;private panelOwnershipObserver?;private panelOwnershipObserverDocument?;private panelOwnershipObserverGeneration;private constraintIssueKey;private initializedSizes;private measuredInlineSize;private _effectiveOrientation;private baseEl?;private collapseResizeObserver?;private collapseObservedElement?;private collapseObserverOwnerDocument?;private collapseObserverGeneration;private gutterResizeObserver?;private gutterObserverFrame?;private gutterObserverDocument?;private gutterObservedDividers;private gutterObservedContainerSize;
/** Owns breakpoint resolution, basis selection, and the viewport `MediaQueryList` lifecycle
*  (including teardown on disconnect) — see `OrientationBreakpointController`. */
private orientationBreakpoints;
/** Owns both collapse thresholds together, their basis, and the viewport `MediaQueryList`
*  lifecycle — see `CollapseBreakpointController` for why the three-state classification can't
*  be two independent single-threshold controllers. */
private collapseBreakpoints;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;protected firstUpdated(changed:PropertyValues):void;
/** Both branches here derive one reactive property from another with no
*  DOM measurement involved, so they belong in `willUpdate()` rather than
*  `updated()`: setting a reactive property from `updated()`/
*  `firstUpdated()` schedules a *second* update on top of the one that
*  just finished, which Lit's dev-mode console flags ("scheduled an
*  update ... after an update completed"). Both of these were real and
*  reproducible in normal usage, not just test artifacts --
*  `ensureSizes()` on any direct `sizes` assignment whose length doesn't
*  match `panelCount` (e.g. a consumer correcting a stale layout), and the
*  `collapseState` reset on every `collapse` -> `'none'` transition. The
*  `collapse !== 'none'` re-arm path in `syncCollapseObserver()` still
*  needs a freshly measured container width and stays in `updated()` --
*  see `armCollapseObserver()`'s own doc comment for why *that* one is the
*  documented exception instead (mirrors virtual-list.ts's
*  `attachContainerListeners()`). */
protected willUpdate(changed:PropertyValues):void;
/**
* The collapsing pane's effective responsive state. Always one of the three
* real states — never `'auto'` — and always `'wide'` while collapse is
* disabled or fewer than two panels exist. Otherwise it reflects either the
* live measured width or, once forced, whatever was last assigned. See the
* class doc for the full force/auto contract.
*/
get collapseState():LyraMultiSplitCollapseState;set collapseState(next:LyraMultiSplitCollapseStateInput);
/**
* Expands the collapsing pane through whichever mechanism its CURRENT BAND provides: inside the
* `floatBreakpoint` band that is the overlay drawer (`open = true`, RELEASING a pin that holds
* another state first, since a pinned rail would otherwise swallow the request); above it the
* mechanism is the pin itself, so the pane is pinned to `'wide'`. A no-op while `collapse` is
* `'none'` or fewer than two panels exist, and a no-op when the pane already presents its
* content. Never renders a trigger of its own -- wire it to your own control.
*
* Pinning is skipped whenever the band already produces the requested state, and a pin that is
* cancelled by this call is released rather than re-pinned, so a consumer-driven expand/collapse
* cycle leaves automatic breakpoint tracking exactly as it found it.
*/
expandPane():void;
/**
* Collapses the collapsing pane through whichever mechanism its current band provides: inside the
* floating band that is closing the overlay drawer (`open = false`), above it a pin to `'rail'`.
* Same no-op rules and same pin hygiene as `expandPane()`.
*/
collapsePane():void;
/**
* Flips the collapsing pane between the two above, reading the pane's current presentation:
* `'wide'` counts as expanded, `'rail'` as collapsed, and `'floating'` as expanded exactly while
* `open`. So toggling a pane pinned to `'rail'` while the container is inside the floating band
* opens the drawer -- the band, not the pin, owns the mechanism.
*
* Named `togglePane()` (with `expandPane()`/`collapsePane()`) because `collapse` is already this
* component's pane-selection property, mirroring `<lr-page>`'s `showNavigation()` trio.
*/
togglePane():void;
/** Whether the collapsing pane currently presents its content. */
private get paneExpanded();private applyPaneIntent;
/** Drops a pin and the band it was created in together, so the two can never disagree. */
private releaseCollapsePin;
/** The width a band classification should read outside the `ResizeObserver` callback: the live
*  `[part="base"]` box once it exists, else the seeded/last-observed `measuredInlineSize`. Never
*  the bare `0` `currentMeasuredWidth()` returns before the first render, which would classify
*  every pre-render pin into the floating band. */
private pinMeasurementWidth;
/** The live layout and resize axis after applying `orientationBreakpoint` — identical to
*  `orientation` whenever `orientationBreakpoint` is unset (or set to something that doesn't
*  resolve to a length). Also reflected as the `data-effective-orientation` host attribute (only
*  present while `orientationBreakpoint` resolves, mirroring `data-collapse-state`'s
*  only-present-while-active contract) so CSS can
*  target the live axis directly instead of every consumer duplicating this fallback. */
get effectiveOrientation():LyraOrientation;
/** Whether the shared collapse/orientation `ResizeObserver` needs to be armed at all — true when
*  either responsive feature (`collapse` or a *container-basis* `orientationBreakpoint`) is opted
*  into, since both are driven off the same measured `[part="base"]` width (see
*  `armCollapseObserver()`). A viewport-basis *orientation* breakpoint is driven by `matchMedia`
*  instead and contributes no arming of its own.
*
*  `collapseBreakpointBasis="viewport"` deliberately does NOT drop the observer the way the
*  orientation feature's viewport basis does: the measurement it feeds (`measuredInlineSize`) is
*  still read by `updateEffectiveOrientation()` for a container-basis orientation breakpoint, and
*  by the `collapseState = 'auto'` release path, which re-derives from the current measured
*  width. Collapse's basis therefore changes only which values `classify()` consults, never
*  whether the split measures itself. */
private get responsiveObservationEnabled();
/** Classifies a measured inline size into the effective resize/layout axis and, only on an
*  actual transition, applies it — mirrors `updateCollapseState()`'s shape. `shouldEmit` is
*  true only when the caller is acting on a *fresh* read: the shared `ResizeObserver`
*  callback's own fresh measurement (container basis), or the `willUpdate()` caller when basis
*  is `'viewport'` (where `configure()` just re-armed `matchMedia` synchronously, so `isBelow()`
*  is already live rather than a stale snapshot). It's false for the container-basis
*  property-driven re-derivation in `willUpdate()`, which only re-maps the last known
*  `measuredInlineSize` and defers the emit to the `ResizeObserver`'s next fresh callback.
*  Matches `applyCollapseStateChange()`'s only-fire-on-a-real-transition contract for
*  `lr-multi-split-orientation-change`. Safe to call `requestUpdate()` unconditionally here even from
*  the mid-cycle `willUpdate()` path — see `willUpdate()`'s own doc comment for why that's the
*  documented exception (unlike `updated()`/`firstUpdated()`, `willUpdate()` runs before Lit
*  clears its pending-update flag, so this can't schedule a redundant second update). */
private updateEffectiveOrientation;
/** The container width (px) `[part="base"]` is measured at right now --
*  used to re-derive `collapseState` immediately when a forced value is
*  released back to `'auto'`, outside of the `ResizeObserver`'s own
*  (async, entry-driven) callback. Mirrors the synchronous initial read
*  `armCollapseObserver()` already does when it (re-)arms. */
private currentMeasuredWidth;
/** Resolves the consumer/observer-requested state through the feature's
* actual availability. A forced rail/floating value can be remembered while
* collapse is disabled, but the public/reflected/effectful state stays wide
* until a real pane exists. */
private effectiveCollapseStateFor;
/** Applies the effects of an effective transition. Requested state and
* effective state are deliberately separate so disabled forced writes never
* create a backdrop, event, focus trap or scroll lock. */
private applyEffectiveCollapseTransition;
/** Moves focus off the collapsing pane when the state it is transitioning into stops presenting
*  that pane's content: `'rail'` clamps it to `railWidth` and clips the overflow, and `'floating'`
*  while closed hides it outright. The open floating drawer is excluded -- the shared overlay
*  manager owns focus there (see `activateFloatingOverlay()`).
*
*  Focus anywhere else, including in a surviving pane or on a divider, is left strictly alone:
*  the owner passed to the shared repair is the collapsing panel itself, not the host. */
private relocateFocusOutOfCollapsingPanel;
/** Survivor first, then this component's own dividers. A surviving pane is usually a plain
*  container that cannot take focus at all, in which case the shared repair moves on by itself
*  (it verifies focus actually landed) and the divider -- a real, labelled `role="separator"` --
*  takes it instead. The still-enabled dividers are preferred over the one the collapse just
*  disabled, which stays in the list as the last resort of a two-panel split: that split has
*  exactly one divider, and losing focus to `<body>` is worse than landing on a separator
*  announced as disabled, which is still a labelled, reachable, escapable stop inside the
*  component. De-duplicated so an enabled divider is never attempted twice by the shared
*  repair. */
private collapseFocusFallbacks;private setOpen;requestUpdate(name?:PropertyKey,oldValue?:unknown,options?:PropertyDeclaration):void;private setRequestedCollapseState;private get storageFullKey();
/** Reads the domain identities for a complete panel sequence. A single missing, blank,
*  whitespace-unstable, or duplicate
*  value invalidates the whole identity model so persistence can never silently fall back to
*  positional ownership. Retained identities are never rewritten. */
private panelIdsFor;
/** Maps the live percentages from the previous ordered panel sequence onto the next sequence by
*  `panelId`. Existing panels retain their relative proportions, new identities receive one
*  equal-share slot, and removed identities release their share proportionally. */
private reconcileIdentitySizes;private reconcileSizesByPanelId;private validInitialSizes;
/** Post-mount assignments use the feasible shared floor. A configured `min` can exceed the
* aggregate available space, in which case interaction deliberately falls back to
* `normalizedDefaultMin()` rather than freezing every divider. */
private validLiveSizes;
/** Resolves `defaultSizes` to a percent-space array for `initializeSizes()`, or `null` when it is
*  empty/unusable. A **pure-number** array keeps strict behavior -- it is
*  passed straight to `validInitialSizes()` with no normalization, so `[30, 60]` is still rejected.
*  Only when at least one entry is a CSS length string are lengths resolved against the measured
*  container (numbers as percent-of-container; strings through the shared contextual
*  `resolveCssLength`) and then normalized to percentages. */
private resolveDefaultSizes;private initializeSizes;private loadPersisted;private persist;private ensureSizes;private readPanelStyle;private samePanelStyle;private snapshotPanelOwnership;
/** Adopts author mutations made while a panel is owned before reasserting
* the effective split projection. These latest values become the release
* baseline, rather than the stale values from initial acquisition. */
private adoptPanelOwnership;private applyOwnedPanelStyle;private applyOwnedPanelStyleValue;private applyOwnedPanelHidden;private applyOwnedPanelCollapseState;private restorePanelOwnership;private panelProjectionDiverged;private resetPanelOwnershipObserver;private observeOwnedPanels;private samePanelSequence;private syncPanelMembership;private releaseOwnedPanels;private onSlotChange;
/** The container extent (px) along the resize axis, read live so a
*  container resize between calls is always picked up — same live read
*  `onPointerMove` already does via `drag.base.clientWidth/clientHeight`. */
private getContainerSize;private resetGutterObserver;
/** Read CSS box dimensions in the divider's own font context, before any visual transform.
*  Panels can have different fonts, so inheriting an unresolved em token would change its size. */
private updateGutterBudget;private syncGutterObserver;
/** The physical panel index `collapse: 'start' | 'end'` resolves to, or
*  `-1` when collapse is off (`'none'`) or there are fewer than 2 panels
*  to collapse one of. Panels are laid out via ascending inline `order`
*  (see `updated()`) and that ordering is never re-swapped for RTL — only
*  the drag/keyboard *delta sign* mirrors for RTL, exactly like
*  `onPointerMove`/`onDividerKeyDown` — so panel index 0 already renders
*  at the logical inline-start edge under both LTR and RTL (confirmed by
*  the pointer-drag RTL test elsewhere in this file: panel 0 renders on
*  the visual *right*, i.e. the RTL inline-start side). `'start'` therefore
*  always resolves to index 0 and `'end'` to `panelCount - 1`, regardless
*  of `isRtl(this)` — consulting it here would swap collapse onto the
*  panel that visually sits at the *other* logical edge, which would be a
*  bug against this component's own RTL rendering, not a fix for one.
*/
private get collapsingIndex();
/** Whether a pane is actually collapsed (rail or floating) right now —
*  `false` whenever `collapse === 'none'`, since `collapseState` then
*  never leaves its `'wide'` default. */
private get collapseActive();
/** Dragging/keyboard-resizing is disabled on the one divider immediately
*  adjacent to the currently-collapsed pane (its other side has nothing
*  meaningful to resize against while the pane is rail/floating-width). */
private isDividerDisabled;
/** Classifies the current width into the collapsing pane's responsive state and, only on an
*  actual transition, applies it (via the same `applyCollapseStateChange()` the accessor's
*  forced-value path uses). `width` is consulted only under `collapseBreakpointBasis =
*  'container'`; the viewport basis reads its two media queries instead (see
*  `CollapseBreakpointController`). Gated behind `_forced` so a pinned `collapseState` is never
*  silently overwritten by a subsequent resize — this is also what the accessor's `'auto'`
*  release calls (with the current measured width) to re-derive the state without duplicating
*  the classification logic.
*
*  `shouldEmit` is false only for the very first render's viewport-basis classification, which
*  establishes the starting state rather than transitioning to it — see `willUpdate()`. */
private updateCollapseState;
/** Creates (idempotently) and (re-)observes `[part="base"]` with the shared collapse-state/
*  effective-orientation `ResizeObserver` — a no-op until `baseEl` exists (see
*  `firstUpdated()`/`connectedCallback()`). One observer drives both responsive features off
*  the same measurement (see `responsiveObservationEnabled()`) rather than each arming its own.
*  The observer's first callback supplies the initial layout measurement; keeping the read
*  there avoids mutating reactive state from `firstUpdated()`/`updated()`, which would create a
*  redundant lifecycle update and a Lit warning. */
private armCollapseObserver;private resetCollapseObserver;
/** Reacts to a live `collapse`/`orientationBreakpoint` property change (as opposed to the
*  connect/first-render arming above): turns the shared observer on/off. The `collapseState`
*  reset for the `'none'` case lives in `willUpdate()` instead (see its doc comment) so no
*  stale rail/floating styling survives switching collapse off, without the extra render pass
*  a property set here would cost. */
private syncCollapseObserver;
/** `min` normalized to a finite, non-negative percent floor before it reaches
*  `normalizedDefaultMin()`/`resolveConstraintBounds()`'s clamp math or `loadPersisted()`'s
*  validity check -- an invalid attribute value would otherwise poison every panel's percent
*  bounds with `NaN` or a negative floor. */
private get safeMin();
/** The safe fallback for a shared percent minimum. A value above the
*  available share is still useful as a consumer intent, but it cannot be
*  honored for every panel at once, so reduce it proportionally. */
private normalizedDefaultMin;
/** Resolves all panel bounds together so aggregate feasibility is checked
*  before an individual divider is asked to clamp a pair. An invalid set is
*  rejected as a whole: interaction uses the safe shared minimum instead of
*  exposing a divider whose minimum is greater than its maximum. */
private resolveConstraintBounds;private percentBounds;
/** Whether a panel's constraint needs the clamp()-based flex-basis branch at all (as opposed to
*  the plain bare-percent branch) — true whenever any px or percent bound is set. */
private hasClampConstraint;
/** Builds the min side of a constrained panel's CSS `clamp()` flex-basis. A single specified
*  bound (either unit) is used bare, preserving the exact pre-existing px-only shape; combining
*  two different unit types needs a native CSS `max()` so the browser keeps picking the stricter
*  (larger) bound after a container resize with no extra JS — the component's own percent-based
*  `min` floor is folded in as an always-present third term in that combined case only, since a
*  single bare bound already fully replaces it (mirrors `resolveConstraintBounds()`'s equivalent
*  overwrite-vs-combine split for the JS-side percent bounds). */
private minSideExpr;
/** The max-side mirror of `minSideExpr()` — uses CSS `min()` (stricter = smaller) when combining
*  both unit types; no equivalent shared floor exists to fold in for the max side. */
private maxSideExpr;private clampPair;
/** Emits the cancelable user-interaction proposal before committing it. The
*  existing `lr-resize` notification remains the non-cancelable post-commit
*  signal, so property-driven layouts stay silent while hosts can veto an
*  interaction before it changes their persistence-facing state. */
private requestResize;private applyDelta;
/** The collapsing pane's light-DOM element itself — the `'floating'`
*  drawer's focus-trap/backdrop target. There's no separate shadow-DOM
*  panel to trap focus within (unlike `<lr-app-rail>`'s `[part="panel"]`):
*  the slotted panel *is* the floating drawer, just repositioned via
*  inline styles in `updated()`. */
private get floatingPanelEl();private activateFloatingOverlay;private deactivateFloatingOverlay;private onBackdropClick;
/** Native pointer input retargets from an inert scrim to the allowed base-path ancestor. */
private onModalLayerClick;private onPointerDown;private onPointerMove;private onPointerUp;private removeDragListeners;private endDragGestures;private onDividerKeyDown;private dividerValueRange;protected updated(changed:PropertyValues):void;
/**
* Projects the current collapse/layout state onto the owned panels: the `data-collapse-state`
* markers (per panel and on the host), the `hidden` flag the closed `'floating'` drawer uses,
* and every owned inline style. Idempotent by construction -- it re-reads the live container
* size, re-adopts any author mutation made since the last pass, and rewrites the same owned
* values -- because it runs twice whenever a collapse transition is announced:
* `applyEffectiveCollapseTransition()` calls it immediately BEFORE emitting
* `lr-multi-split-collapse-change`, so a listener reading the panel synchronously inside its
* own handler sees the post-transition decoration rather than the previous render's, and
* `updated()` calls it again for every ordinary render.
*
* `constraintResolution` defaults to a fresh resolution for the caller that has none;
* `updated()` passes the one it already computed for the constraint-issue key, so the ordinary
* render path performs one `resolveConstraintBounds()` and one forced-layout `getContainerSize()`
* read rather than two.
*/
private decorateOwnedPanels;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-multi-split':LyraMultiSplit;}}