import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraFrame,LyraVariant}from'../../../internal/variants.js';import type{LyraTranscriptMode}from'../../../internal/shared-unions.js';export interface ActivityEntry{id:string;text:string;
/** Literal icon hint (e.g. an emoji), like `<lr-tool-call-chip>`'s `icon`. A small variant dot
*  renders in its place when omitted. */
icon?:string;
/** Invalid strings are treated as unset. */
timestamp?:Date|string;
/** Token-mapped, the library's shared `variant` vocabulary. */
variant?:LyraVariant;
/** Opaque caller payload (e.g. the source record this entry summarizes). Never read or
*  rendered by `<lr-activity-feed>` itself -- carried through the owned `entries` snapshot and
*  handed back to `renderText` by reference, never deep-cloned, so a consumer can look up
*  richer per-entry context without re-scanning its own source array by id on every render. */
data?:unknown;}
/** Whether the feed is streaming a run live or replaying a finished one -- the library's shared
*  transcript-mode vocabulary, identical to `<lr-thinking-panel>`'s `ThinkingPanelMode`. */
export type ActivityFeedMode=LyraTranscriptMode;export interface ActivityFeedToggleDetail{expanded:boolean;}export interface ActivityFeedFollowChangeDetail{following:boolean;}export interface LyraActivityFeedEventMap{'lr-toggle':CustomEvent<ActivityFeedToggleDetail>;'lr-follow-change':CustomEvent<ActivityFeedFollowChangeDetail>;}
/**
* `<lr-activity-feed>` — an append-only streaming log of granular agent actions ("Searching the
* web…", "Read src/index.ts"), collapsing to a localized "Completed N steps" summary once the run
* is over. Entries never change state once added (a step whose status mutates in place belongs to
* `<lr-task-list>` instead). Implements the shared follow (stick-to-bottom) contract: `follow`
* is a component-managed, host-assignable property, released on user scroll-up and re-engaged at
* the bottom. `lr-follow-change` reports user-driven transitions only; direct host assignments are
* controlled input and never echo an event. At/above
* `virtualizeAt` entries, the body renders through an internal `<lr-virtual-list>`
* instead of a plain keyed list — same list semantics either way, keyed by `id`. Empty/blank ids
* are omitted and duplicates normalize before counts, follow calculations, and rendering; the
* first occurrence wins.
*
* Each entry's `text` renders as plain text by default; a host needing richer per-entry content
* (rendered markdown, a trailing tool-call chip list, etc.) sets `renderText` to replace the
* default text inside the stable `entry-text` styling wrapper, identically whether or not the feed
* is currently virtualized. An entry's optional `data` is an opaque caller payload -- never read
* or rendered by this component -- carried through by reference (never deep-cloned) and handed
* back to `renderText`, so a host needing the original source record behind a rendered line does
* not have to re-derive it by re-scanning its own source array on every render.
*
* `compact` tightens the header and entry-row padding for dense transcript rows. `frame="plain"`
* removes the outside card chrome when a containing message or panel already supplies it; the
* header/body divider remains, so the disclosure keeps its internal structure -- the same two-knob
* convention `<lr-thinking-panel>` and `<lr-confirm-bar>` already establish. The card's own paint
* is retunable without a `::part(base)` override through `--lr-activity-feed-background`,
* `--lr-activity-feed-border-color` and `--lr-activity-feed-radius`; each is an inline `var()`
* fallback at its point of use, so an unset feed renders exactly as before and any of the three can
* be set on the feed or on an ancestor transcript.
*
* Focus is repaired, not merely dropped, when the currently focused control disappears from under
* it: collapsing (`expanded` becoming `false`) moves focus already inside the body to
* `[part="header"]` before the body is hidden, and an `entries` update that removes the specific
* row holding focus does the same once that update (and, while virtualized, the internal
* `<lr-virtual-list>`'s own follow-up render) has settled. Neither case fires when focus is
* elsewhere -- appending a live entry never steals focus from an unrelated, still-present control.
*
* 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-activity-feed
* @event lr-toggle - The header was activated, expanding or collapsing the body. `detail: {
*   expanded }`.
* @event lr-follow-change - A user scroll released or re-engaged `follow`. `detail: {
*   following }`. Direct property/attribute assignments never echo an event.
* @csspart base - The outer container.
* @csspart header - The clickable header (`<button>`).
* @csspart status-dot - The decorative mode indicator dot; pulses while `mode="live"`.
* @csspart label - The header's title text — `label`, or its localized default when `label` is
*   omitted.
* @csspart summary - The header's one-line ticker (`live`) or completed-count summary
*   (`post-hoc`).
* @csspart toggle - The chevron indicator inside the header.
* @csspart body - The scrollable region containing the entries (or the internal virtual-list).
* @csspart entry - One entry row; carries `data-variant`.
* @csspart entry-icon - The literal `icon` hint, or a variant dot when unset.
* @csspart variant-dot - The variant dot rendered inside `entry-icon` when the entry sets no
*   literal `icon`. Its own named part rather than an internal class, so it stays styleable in both
*   the plain and virtualized rendering paths and reachable from a consumer's `::part()`. Also
*   carries a variant-specific name, since `::part()` cannot be qualified by `[data-variant]`.
* @csspart variant-dot-neutral - An entry with no `variant`'s dot (also carries `variant-dot`).
* @csspart variant-dot-brand - A `brand`-variant entry's dot (also carries `variant-dot`).
* @csspart variant-dot-success - A `success`-variant entry's dot (also carries `variant-dot`).
* @csspart variant-dot-warning - A `warning`-variant entry's dot (also carries `variant-dot`).
* @csspart variant-dot-danger - A `danger`-variant entry's dot (also carries `variant-dot`).
* @csspart entry-text - The entry's text styling wrapper. `renderText`, when set, supplies rich
*   content inside this stable part instead of replacing the part itself.
* @csspart entry-timestamp - The formatted timestamp, only rendered while `showTimestamps` and a
*   valid `timestamp` is set.
* @cssprop [--lr-activity-feed-max-height=16rem] - Cap on how tall the expanded body grows
*   before it scrolls internally (non-virtualized mode); also sizes the internal virtual-list.
* @cssprop [--lr-activity-feed-live-status-color=var(--lr-color-brand)] - Background color of
*   `status-dot` while `mode="live"`.
* @cssprop [--lr-activity-feed-compact-header-padding=var(--lr-space-2xs) var(--lr-space-s)] -
*   `[part="header"]` padding while `compact`.
* @cssprop [--lr-activity-feed-compact-header-gap=var(--lr-space-2xs)] - Gap between the header
*   toggle, status dot, label, and summary while `compact`.
* @cssprop [--lr-activity-feed-compact-entry-padding=var(--lr-space-2xs) var(--lr-space-s)] -
*   `[part="entry"]` padding while `compact`.
* @cssprop [--lr-activity-feed-background=var(--lr-color-surface)] - Fill of the outer card
*   (`[part="base"]`) while `frame="card"`. `frame="plain"` still removes the fill entirely.
* @cssprop [--lr-activity-feed-border-color=var(--lr-color-border)] - Colour of the outer card's
*   border and of the header/body divider, which `frame="plain"` keeps.
* @cssprop [--lr-activity-feed-radius=var(--lr-radius)] - Corner radius of the outer card.
*   `frame="plain"` still squares the corners.
* @status stable
* @since 4.0.0
*/
export declare class LyraActivityFeed extends LyraElement<LyraActivityFeedEventMap>{protected static readonly ownedCollectionProperties:readonly string[];
/** Entries may carry opaque caller `data`. Keep each admitted entry's identity only, rather
*  than deep-cloning unknown data -- the same policy `<lr-prompt-queue>`'s `items` uses for its
*  own opaque `metadata` field. */
protected static readonly identityCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];
/** Append-only: stable ids, new entries at the end. Entries never change state once added.
*  Empty/blank ids are omitted and duplicates normalize first-wins before summary,
*  virtualization, and rendering. */
entries:readonly ActivityEntry[];
/** `'live'` follows the tail (per `follow`) and pulses; `'post-hoc'` shows the completed-count
*  summary and never scrolls. */
private _mode;get mode():ActivityFeedMode;set mode(next:ActivityFeedMode);
/** Component-managed, host-assignable stick-to-bottom flag — released on user scroll-up,
*  re-engaged at the bottom. Only drives scrolling in `'live'` mode. */
follow:boolean;
/** Body visibility. Never self-mutated on `mode` changes — a host wanting the finished feed
*  collapsed sets `mode="post-hoc"` and `expanded=false` together. */
expanded:boolean;
/** Optional header-text override. Omission localizes `activityFeedLabel`; any supplied string,
*  including `'Activity'` or `''`, is rendered verbatim. The semantic list uses an authored host
*  `aria-label` when present (including an explicit empty value), otherwise its localized
*  `activityFeedLabel` fallback, while this remains the visible header text. */
label?:string;
/** Tighter header and entry-row padding for dense transcript contexts. Defaults to `false`,
*  preserving the regular-density treatment. This changes density only; the outer border and
*  surface remain, so use `frame="plain"` to remove card chrome. */
compact:boolean;
/** Visual chrome, in the library's shared container-frame vocabulary. `'card'` (the default)
*  keeps the bordered, filled outer container. `'plain'` removes that outer border, background,
*  and corner radius so a feed nested inside existing message chrome does not double it. Plain
*  preserves the header/body divider and whichever regular or compact padding applies. */
frame:LyraFrame;
/** Trailing `<time datetime>` per entry, default `hour:minute` in `effectiveLocale`. */
showTimestamps:boolean;
/** Overrides the default `hour:minute` rendering of every entry's `timestamp`. */
formatTimestamp?:(date:Date)=>string;
/** Overrides the default plain text inside every `[part="entry-text"]` wrapper with an arbitrary
*  `TemplateResult` (e.g. rendered markdown, or markdown plus a trailing list of
*  `<lr-tool-call-chip>`s). The stable wrapper remains available for styling in both rendering
*  paths, since both render every entry through the same internal template. */
renderText?:(entry:ActivityEntry)=>TemplateResult;
/** At/above this entry count, the body renders through an internal `<lr-virtual-list>`. */
virtualizeAt:number;private liveRegion?;private virtualListEl?;private readonly headerId;private readonly bodyId;
/** Stable across renders on purpose -- a fresh closure here would defeat the internal
*  `<lr-virtual-list>`'s row-offset cache (it treats a `keyFunction` identity change the
*  same as an `items` change) on every unrelated re-render. */
private readonly activityEntryKey;
/** `true` until the first completed update -- gates the mode-transition announcement so
*  mounting in a non-default mode never announces historical state. */
private isMounting;private scrollRafId?;private scrollRafOwner?;private scrollRafDocument?;private virtualAnchorReleaseRafId?;private virtualAnchorReleaseRafOwner?;private virtualAnchorReleaseRafDocument?;private anchoringVirtualTail;private ownerRealmGeneration;private virtualAnchorRequest;private externalLabelledByLease?;private externalDescribedByLease?;private relationshipSyncRequest;
/** Captured in `willUpdate()` before an `entries` change re-renders, settled in `updated()`
*  once it's clear whether the specific row that held focus actually disappeared. The snapshot
*  already records that row as its `activeElement`, so no parallel node field is kept. */
private pendingEntryFocusRepair?;private entryFocusRepairRequest;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;
/** `virtualizeAt`, normalized to a finite non-negative integer (falling back to the
*  property's own default of `199`) -- a raw `NaN` (e.g. an invalid `virtualize-at`
*  attribute) would otherwise make `entries.length > virtualizeAt` always false,
*  silently disabling virtualization instead of falling back to the default threshold. */
private get effectiveVirtualizeAt();private get normalizedEntries();private get isVirtualized();private get shouldFollowLiveTail();private cancelScrollFrame;private cancelVirtualAnchorReleaseFrame;private resetOwnerRealmWork;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;
/** The always-rendered header button, this component's single focus-repair fallback target. */
private get headerElement();
/** Moves focus already inside the body to `[part="header"]` before the body becomes hidden --
*  the shared helper's synchronous capture-then-apply, called from `willUpdate()`, the same
*  shape `<lr-callout>`'s own collapse handling uses. The header renders regardless of
*  `expanded`, so its focusability never depends on the render this `willUpdate()` is about to
*  commit, and no async settle (or generation guard) is needed. A no-op when focus is
*  elsewhere. */
private repairFocusOnCollapse;
/**
* Captures a possible focus repair before an `entries` change re-renders. Unlike collapsing,
* whether repair is actually needed depends on whether the *specific* row that held focus
* survives the render -- appending a new live entry must never steal focus from an unrelated,
* still-present control. `settleEntryFocusRepair()` (`updated()`) resolves that once the render
* (and, while virtualized, the internal `<lr-virtual-list>`'s own follow-up render) has
* committed, by checking whether the originally focused node is still connected.
*/
private captureEntryFocusRepair;
/** Settles a capture from `captureEntryFocusRepair()`. Guarded by `entryFocusRepairRequest` (a
*  newer capture supersedes an older, still-pending one) and `ownerRealmGeneration` (a
*  disconnect/adopt in between invalidates it) so a stale check can never steal focus that has
*  since legitimately moved elsewhere. */
private settleEntryFocusRepair;private scrollToLatest;private completedStepsSummary;
/** The element that owns the real list role in either rendering path. The virtual list's public
*  scrollContainer is its internal `[part="base"]` list owner, not the composed custom-element
*  host, so host IDREF relationships reach the semantic element without widening virtual-list's
*  public API. */
private get listSemanticOwner();
/** Projects both authored host IDREF relationships onto the current semantic list owner. */
private syncListRelationships;
/** A parent update can finish before the composed virtual list creates its real list owner. */
private scheduleListRelationshipSync;private releaseListRelationships;private toggle;private setFollowFromUser;private onBodyScroll;private onVirtualListRangeChanged;private stopOwnedEvent;private normalizedTimestamp;private entryTemplate;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-activity-feed':LyraActivityFeed;}}