import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraOrientation}from'../../../internal/shared-unions.js';import type{LyraTimelineItem}from'./timeline-item.class.js';
/** How a timeline distributes its items along the main axis. */
export type LyraTimelineScale='flow'|'time';
/** How `scale="time"` handles items that land on (nearly) the same position. */
export type LyraTimelineCollision='overlap'|'stack'|'cluster';export interface LyraTimelineClusterActivateDetail{
/** The clustered `<lr-timeline-item>` elements, as a frozen snapshot in document order. */
readonly items:readonly LyraTimelineItem[];}export interface LyraTimelineEventMap{'lr-cluster-activate':CustomEvent<LyraTimelineClusterActivateDetail>;}
/**
* `<lr-timeline>` — an ordered, connected sequence of past-event rows (an audit trail, an agent
* action history, a changelog) composed from `<lr-timeline-item>` light-DOM children, joined by a
* continuous connecting rail. First-party invention: no Web Awesome/Shoelace counterpart exists, so
* this follows the library's own established conventions rather than mirroring an upstream API.
*
* A read-only declarative display by default — same zero-interaction shape as `<lr-badge>`/
* `<lr-avatar>`/`<lr-skeleton>`. The opt-in `scale="time" collision="cluster"` presentation is the
* one exception: overlapping events collapse behind a native count button and activation emits
* their exact element identities so the consumer can open its own popover, dialog, or detail
* view. The component does not select, expand, reorder, or mutate the content of those items.
*
* No roving-tabindex or per-event selection model is introduced. Timeline items remain passive;
* each cluster marker is an independent native `<button>` in the normal Tab sequence, so pointer,
* Enter, and Space activation require no custom keyboard model. The one tab stop the timeline
* itself owns is `[part='base']` while a `horizontal` strip genuinely overflows — passive items
* leave nothing tabbable inside a scroll container, so without it the events scrolled off the edge
* are pointer-only content. Not a form-associated control — no value to submit, no
* label/hint/error chrome.
*
* The first member in document order represents a cluster: its ordinary shadow row is temporarily
* replaced by the count action while the remaining members are hidden. This preserves the author's
* list and Tab order instead of appending visually positioned controls after the slot. The action
* exposes `cluster` and `cluster-count` parts on that representative `<lr-timeline-item>`.
*
* @customElement lr-timeline
* @slot - `<lr-timeline-item>` children, in display order.
* @event lr-cluster-activate - A `collision="cluster"` count marker was activated by pointer,
*   Enter, or Space. `detail: { items }` contains a fresh frozen snapshot of the member
*   `<lr-timeline-item>` elements in document order. Non-cancelable notification; the timeline has
*   no built-in expansion or selection action to veto.
* @csspart base - The root wrapper. `role="list"` lives here directly (a timeline isn't a navigation
*   landmark, so it doesn't need a two-layer `base`+`list` split). Flex container: `flex-direction:
*   column` in `vertical` orientation (the default), `flex-direction: row` (with `overflow-x: auto`,
*   `overflow-y: hidden`, and an edge-fade `mask-image` applied only while the strip actually
*   overflows) in `horizontal` orientation. Its `tabindex` rises from `-1` to `0` while (and only
*   while) that horizontal strip genuinely overflows: timeline items are passive, so nothing
*   inside is tabbable and the off-screen events would otherwise be pointer-only content. Style
*   that state with `::part(base):focus-visible`.
* @cssprop [--lr-timeline-gap=var(--lr-space-l)] - Spacing between consecutive items along the
*   timeline's main axis; also the length each item's own rail visually bridges to reach the next
*   item's marker. Declared here but actually consumed inside each `<lr-timeline-item>`'s own
*   stylesheet, via ordinary CSS custom-property inheritance across the slot boundary.
* @cssprop [--lr-timeline-collision-offset=var(--lr-space-l)] - Cross-axis step between items
*   stacked by `collision="stack"`. Each collision lane is indented one step further, so a wider
*   marker can claim more room without the lanes overlapping again. Ignored unless both
*   `scale="time"` and `collision="stack"` are set.
* @cssprop [--lr-timeline-cluster-size=var(--lr-size-2rem)] - Minimum inline and block size of the
*   painted count pill. Its containing button retains the shared 40px minimum action surface.
* @cssprop [--lr-timeline-cluster-bg=var(--lr-color-brand)] - Cluster count pill background.
* @cssprop [--lr-timeline-cluster-color=var(--lr-color-on-brand)] - Cluster count pill foreground.
* @cssprop [--lr-timeline-time-extent=var(--lr-size-20rem)] - Distance the `scale="time"` axis
*   distributes items along: `block-size` when vertical, `inline-size` when horizontal. Time-scaled
*   items are absolutely positioned, and a percentage offset against an auto-sized track resolves
*   to zero, so the axis needs a definite extent. Horizontal overlap and stack modes measure
*   actual item/lane height independently and update it when content changes. Ignored in the
*   default `scale="flow"`.
* @cssprop [--lr-scroll-fade-size=2rem] - Inline size of each edge fade while a
*   horizontal timeline overflows. Forced-colors mode disables the masks while retaining native
*   scrolling.
* @status stable
* @since 4.0.0
*/
export declare class LyraTimeline extends LyraElement<LyraTimelineEventMap>{protected static readonly immutableEventDetails:readonly string[];protected static readonly identityEventDetailProperties:Readonly<{'lr-cluster-activate':readonly string[];}>;static styles:import("lit").CSSResultGroup[];
/** `'vertical'` (the default) lays items out in a column, the primary/most-common use case — an
*  audit trail or agent history reads top-to-bottom. `'horizontal'` lays them out in a row.
*  Deliberately differs from `<lr-stepper>`'s `'horizontal'` default — don't copy that default by
*  habit. */
private _orientation;get orientation():LyraOrientation;set orientation(value:LyraOrientation);
/**
* How items are distributed along the main axis.
*
* `'flow'` (the default) is today's behavior exactly: an evenly-spaced sequence, where
* `timestamp` is rendered as text but carries no positional meaning. `'time'` positions each item
* at its true proportion of the time range, so a gap of weeks and a gap of decades no longer look
* identical — the shape of the history becomes visible.
*
* `'time'` needs a definite extent to distribute along, which comes from
* `--lr-timeline-time-extent` (default `20rem` block-size when vertical, inline-size when
* horizontal). Items are absolutely positioned within it. The `collision` property controls
* whether nearby items overlap, fan into lanes, or collapse behind an activatable count marker.
*
* An item with no `timestamp` this component can parse (including one whose timestamp comes only
* from the `timestamp` slot, which carries no machine-readable instant) keeps document order and
* is distributed evenly, so a partially-timestamped list degrades rather than collapsing.
*/
private _scale;get scale():LyraTimelineScale;set scale(value:LyraTimelineScale);
/**
* What `scale="time"` does with items that land on (nearly) the same position.
*
* `'overlap'` (the default, and the only previous behavior) leaves them stacked on top of one
* another. `'stack'` offsets each colliding item along the **cross** axis instead, so a dense
* chronology with many same-period events stays readable. `'cluster'` represents each group of
* overlapping items with one author-ordered member's count marker. Its collision window grows
* from the ordinary 1.5%
* floor to the rendered count button's footprint on the currently allocated axis, preventing
* interactive markers from overlapping after an allocation or themed-size change. Activating it
* emits `lr-cluster-activate` with the member elements but does not select or expand them. Ignored
* unless `scale="time"`.
*/
private _collision;get collision():LyraTimelineCollision;set collision(value:LyraTimelineCollision);
/** Pins the axis start instead of deriving it from the earliest item. Ignored unless
*  `scale="time"`; a non-finite or reversed pair falls back to the derived range. */
rangeStart?:Date|string|number;
/** Pins the axis end instead of deriving it from the latest item. Ignored unless
*  `scale="time"`; a non-finite or reversed pair falls back to the derived range. */
rangeEnd?:Date|string|number;
/** Host-level `aria-label` override for the list's accessible name — wins over the localized
*  default `"Timeline"`. Needed because the `role="list"` element lives in the shadow root and
*  never inherits a host attribute automatically — same reasoning as `<lr-breadcrumb>`'s
*  identical property. Unset falls back to the localized default; an explicitly empty
*  `aria-label` stays empty. */
accessibleLabel?:string;private slottedCount;private collisionClusters;private readonly managedClusterHiddenItems;private readonly managedClusterRepresentatives;private readonly clusterActivations;private readonly timestampObservedItems;private clusterMeasurementFrame?;private clusterMeasurementView?;private timeExtentFrame?;private timeExtentView?;private focusRepairGeneration;
/** Gates the horizontal [part='base'] edge fade on the strip genuinely overflowing, with
*  one-sided/RTL-aware logical-edge state -- see --lr-scroll-fade-size and timeline.styles.ts.
*  Harmless in the vertical default, where the strip never scrolls inline and the attribute
*  simply stays off. Stored (rather than a bare statement-expression call) so `updated()` can
*  register each timeline item on the controller's own `ResizeObserver` via `observeExtra()`
*  below -- an item's own intrinsic content (a longer title, an icon loading in) can grow
*  scrollWidth without [part='base']'s own border box changing at all. */
private scrollOverflow;connectedCallback():void;disconnectedCallback():void;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;
/** Makes the horizontal strip reachable by keyboard while, and only while, it genuinely
*  overflows.
*
*  Timeline items are deliberately passive (see the class doc: no roving tabindex, no selection
*  model), so a `horizontal` strip is a scroll container with nothing tabbable inside it. At
*  `tabindex="-1"` it is focusable only by script -- Tab cannot reach it -- so every event that
*  had scrolled off the edge was pointer-only content, which is the WCAG 2.1.1 keyboard failure
*  `<lr-stepper readonly>` hit in the same shape and fixes the same way.
*
*  Gated on real overflow so a strip that fits (and the `vertical` default, whose rules never
*  give `[part='base']` a scrolling axis at all) still costs a keyboard user nothing -- and
*  returns to the `tabindex="-1"` the template renders rather than dropping the attribute, so a
*  consumer's own script-focus target survives. Written as an attribute rather than through the
*  template because overflow is measured, not rendered; the static `tabindex` in `render()` is
*  cloned once and never re-committed, so an imperative write here is stable. */
private syncScrollTabStop;private countTimelineItems;firstUpdated(changed:PropertyValues):void;
/** Read-only, live-updated count of default-slot `<lr-timeline-item>` assignments, including
*  flattened forwarding slots — handy for building a `"{count} events"` header without
*  hand-counting DOM children. */
get itemCount():number;private onSlotChange;private onTimelineItemTimestampChange;private syncTimestampObservers;
/** The slotted `<lr-timeline-item>` children, in document order. */
private timelineItems;
/** The axis bounds: an explicitly pinned pair when both ends are finite and ordered, otherwise
*  the earliest and latest parseable item timestamps. `null` when fewer than two distinct
*  instants exist, since a zero-width range cannot be divided. */
private timeRange;
/**
* Writes each item's position as a percentage into `--_lr-timeline-item-offset`, consumed by
* timeline.styles.ts's `scale="time"` rules.
*
* Deliberately a style write on the light-DOM child rather than a wrapper element per item: the
* component never mutates its children's content or structure. The private position properties
* and cluster visibility marker are presentation-only and are removed when their modes end.
*/
private applyTimeScale;
/**
* Assigns each time-scaled item a cross-axis lane so coincident items stop covering each other.
*
* Walks items in ascending offset order and gives each the lowest lane not already taken by a
* still-colliding earlier item, so a run of three same-year events occupies lanes 0/1/2 while an
* isolated event later on returns to lane 0 rather than inheriting the run's depth. Lane 0 is
* written as well as the others, so switching back to `'overlap'` (or leaving `'stack'` unset)
* clears every lane rather than leaving stale offsets on some children.
*/
private applyCollisionLanes;
/** Groups sorted offsets into bounded collision windows. Each window is anchored at its first
* item rather than chained transitively through every adjacent neighbour, so a large uniformly
* dense history becomes a sequence of useful count markers instead of one axis-wide group. */
private buildCollisionClusters;
/** The minimum fraction shared with stack mode, widened when the rendered native actions need
* more of the allocated axis to avoid overlapping hit targets. Re-evaluated after every cluster
* render and by the existing owner-realm ResizeObserver attached to the base and actions. */
private clusterCollisionThreshold;
/** Absolute time items do not contribute intrinsic height. Measure their layout boxes and
* lane offsets after layout, sharing the existing item ResizeObserver for later content changes. */
private scheduleTimeExtentMeasurement;private cancelTimeExtentMeasurement;
/** Coalesces ResizeObserver-driven membership writes into the next owner-realm frame. Updating
* observed cluster actions synchronously inside their observer callback would create a resize
* notification loop whenever a larger count changes the action's footprint. */
private scheduleClusterMeasurement;private cancelClusterMeasurement;private sameClusters;private captureClusterFocusRepair;private scheduleClusterFocusRepair;private applyCollisionClusters;private syncClusterPresentations;private restoreClusterPresentation;private restoreClusterVisibility;private activateCluster;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-timeline':LyraTimeline;}}