import type{LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import{type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';export type{LyraNodeTypeStyle}from'../../../internal/node-type-style.js';import{type LyraSpan}from'../trace-tree/span.js';export type{LyraSpan}from'../trace-tree/span.js';export interface LyraAgentTraceEventMap{
/** Bubbles, composed, from the composed `<lr-trace-tree>` (identical `{ spanId }` detail), or is
*  fired directly when a handoff quick-jump entry is activated -- a host handles both origins
*  through this one event. */
'lr-span-select':CustomEvent<{spanId:string;}>;
/** Bubbles, composed, from the composed `<lr-trace-tree>`, unchanged. */
'lr-span-toggle':CustomEvent<{spanId:string;expanded:boolean;}>;
/** Timeline-owned translation of the composed graph legend's visibility event. */
'lr-span-visibility-change':CustomEvent<LyraEventDetailSnapshot<{hiddenKinds:LyraSpan['kind'][];}>>;}
/**
* `<lr-agent-trace>` — a provider-neutral agent/LLM trace view: a span-kind filter row, a
* handoff quick-jump list, and the full trace hierarchy, all driven by one shared `LyraSpan[]`
* array (the same shape `<lr-trace-tree>` and `<lr-span-waterfall>` already consume).
*
* The actual trace rendering -- hierarchy, expand/collapse, roving-tabindex keyboard navigation,
* duration bars, the empty state -- is entirely `<lr-trace-tree>`'s own: this component only ever
* passes it a (possibly filtered) `spans` array plus a handful of pass-through properties, never
* building its own row markup. `<lr-trace-tree>` was chosen over `<lr-span-waterfall>` because a
* trace is fundamentally the hierarchy relationship between spans (which agent called which tool,
* which handed off to which sub-agent) -- exactly what `parentId`-derived `aria-level` nesting
* conveys and a flat, `startMs`-ordered timeline does not.
*
* This component's own contribution is the multi-domain filter layer on top of that: a filter
* row composing `<lr-graph-legend>` -- the same abstract type/visibility-toggle legend pattern
* that component already establishes for `<lr-graph>`'s node types, reused here (it neither
* reads nor writes an actual graph) for `LyraSpan.kind` visibility instead -- and a handoff
* quick-jump list composing `<lr-handoff-divider>` for each visible `'agent'`-kind span (an
* agent invocation is, in trace terms, a handoff of control to that agent). Hidden kinds are
* simply excluded from the array handed to `<lr-trace-tree>`; a span whose parent got filtered
* out is promoted to a root by `<lr-trace-tree>`'s own existing orphan handling, never dropped.
*
* Selection is controlled end-to-end for deep-linking: `activeSpanId` flows down into
* `<lr-trace-tree>` verbatim, and both activation paths -- a row click inside the tree, or a
* handoff quick-jump entry -- update it and fire the identical `lr-span-select` `{ spanId }`
* shape, so
* a host can encode the current span id in a URL and feed it straight back in.
*
* Public collection properties take bounded readonly snapshots. `spans` keeps its admitted item
* identities only long enough for the shared descriptor-safe projection to copy its fields; later
* rendering never re-reads an admitted source row. Create a new collection and reassign it after
* changes; mutating the assigned array does not update the view.
*
* @customElement lr-agent-trace
* @event lr-span-select - `detail: { spanId }` — a span was activated, from the tree or the handoff list.
* @event lr-span-toggle - `detail: { spanId, expanded }` — a tree row was expanded or collapsed.
* @event lr-span-visibility-change - `detail: { hiddenKinds }` — the span-kind filter changed.
* @csspart base - The root wrapper.
* @csspart filter - The composed `<lr-graph-legend>` filter row, only rendered while `spans` has at least one span.
* @csspart handoffs - The handoff quick-jump list wrapper, only rendered while at least one visible span has `kind: 'agent'`.
* @csspart handoff - One handoff quick-jump entry (a `<button>` wrapping an `<lr-handoff-divider>`); carries `data-active`.
* @csspart tree - The composed `<lr-trace-tree>`.
* @cssprop [--lr-agent-trace-handoff-active-bg=var(--lr-color-brand-quiet)] - Background of the active
*   (`activeSpanId`) handoff quick-jump entry. Shadow Parts forbids an attribute selector after
*   `::part()`, so the active entry could otherwise only be restyled by hijacking the library-wide
*   `--lr-color-brand-quiet` token.
* @status stable
* @since 4.1.0
*/
export declare class LyraAgentTrace extends LyraElement<LyraAgentTraceEventMap>{protected static readonly ownedCollectionProperties:readonly string[];
/** Span sources can carry opaque provider metadata; the shared normalizer copies only its closed
* display schema once, so cloning each whole source record would both lose opaque identity and
* create an unsafe second traversal. */
protected static readonly identityCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];protected static readonly immutableEventDetails:readonly string[];
/** The full, unfiltered span array -- identical contract to `<lr-trace-tree>.spans`. Controlled
*  and never mutated by this component; `activeSpanId` and its ancestor path reserve positions
*  inside the shared 500-row projection before kind filtering. */
spans:readonly LyraSpan[];
/** Controlled selection, forwarded verbatim into the composed `<lr-trace-tree>`. Updated
*  locally (and re-emitted as `lr-span-select`) whenever a span is activated from either the
*  tree or the handoff quick-jump list, so a host can also treat it as a two-way binding. */
activeSpanId:string|null;
/** Span kinds currently hidden from the tree. Empty (the default) shows every kind. Controlled
*  -- a host may pre-set this (e.g. to hide `retriever`/`embedding` spans by default) or read it
*  back after `lr-span-visibility-change`. */
hiddenKinds:readonly LyraSpan['kind'][];
/** Optional accessible-name override forwarded to the composed `<lr-trace-tree>`. Omission
*  leaves the composed tree's own `label` unset, so it localizes its own default; any supplied
*  string, including `''`, is forwarded verbatim. See `<lr-trace-tree>`'s own `label` property. */
label?:string;
/** Forwarded verbatim to the composed `<lr-trace-tree>`. */
showTokens:boolean;
/** Forwarded verbatim to the composed `<lr-trace-tree>`. */
showCost:boolean;
/** Shows the inline duration bar on the composed `<lr-trace-tree>`, matching the
*  positive-polarity `showTokens`/`showCost` convention on this same element. Defaults to
*  `true`; set `show-bars="false"` to suppress the bar for dense/narrow embeddings. */
showBars:boolean;private presentKinds;private filteredSpans;private handoffSpans;
/** The handed-off-from agent's name, resolved against the full (unfiltered) `spans` array so a
*  hidden/filtered-out parent's name still renders -- empty when `parentId` is unset or
*  unresolvable, mirroring `<lr-handoff-divider>`'s own "from is optional" contract. */
private handoffFromAgent;
/** Same computation `<lr-handoff-divider>` performs internally for its own `aria-label`, reused
*  here (not reimplemented with different wording) for this button's accessible name. */
private handoffAccessibleLabel;private onVisibilityChange;
/** Keeps the composed legend's cancelable proposal within this wrapper without changing its
* default-prevented state. The child still owns the proposal, commit, and announcement. */
private onBeforeVisibilityChange;
/** Keeps `activeSpanId` (and therefore the handoff list's own highlighting) in sync when
*  selection originates inside the composed `<lr-trace-tree>` rather than the handoff quick-jump
*  list. The original event is never stopped here, so it still reaches a host listener on this
*  element unchanged. */
private onTreeSpanSelect;private selectSpan;private renderFilter;private renderHandoff;private renderHandoffs;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-agent-trace':LyraAgentTrace;}}