@aceshooting/lyra-ui 1.1.0 → 2.0.0

package/dist/components/tool-call-chip/tool-call-chip.js

@@ -0,0 +1,288 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html, svg, nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { defineElement } from '../../internal/prefix.js';
+import { place } from '../../internal/positioner.js';
+import { styles } from './tool-call-chip.styles.js';
+// Mirrors the shared icon set's viewBox/stroke conventions
+// (internal/icons.ts's chevronIcon()/closeIcon()/etc.) without adding
+// tool-call-specific glyphs to that module -- it's off limits here -- so
+// these still read as part of the same visual language as the rest of the
+// library's inline icons. Same approach lyra-checkbox's/lyra-chat-message's
+// own local glyphs take for the identical reason, and deliberately the same
+// shapes lyra-tool-result-dialog's own local glyphs use, so a call reads
+// identically whether it's shown as this inline chip or in that dialog.
+const ICON_VIEW_BOX = '0 0 24 24';
+const ICON_STROKE_WIDTH = '1.75';
+function icon(paths) {
+    return svg `
+    <svg
+      width="1em"
+      height="1em"
+      viewBox=${ICON_VIEW_BOX}
+      fill="none"
+      stroke="currentColor"
+      stroke-width=${ICON_STROKE_WIDTH}
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      aria-hidden="true"
+      focusable="false"
+    >${paths}</svg>
+  `;
+}
+function pendingIcon() {
+    return icon(svg `<circle cx="12" cy="12" r="9"></circle><polyline points="12 7 12 12 15 14"></polyline>`);
+}
+/** A three-quarter arc, spun by the `:host([status="running"]) [part="icon"] svg`
+ *  CSS animation -- a full circle wouldn't visibly convey rotation. */
+function runningIcon() {
+    return icon(svg `<path d="M21 12a9 9 0 1 1-9-9"></path>`);
+}
+function successIcon() {
+    return icon(svg `<circle cx="12" cy="12" r="9"></circle><polyline points="8 12.5 11 15.5 16 9.5"></polyline>`);
+}
+function errorIcon() {
+    return icon(svg `
+    <circle cx="12" cy="12" r="9"></circle>
+    <line x1="9" y1="9" x2="15" y2="15"></line>
+    <line x1="15" y1="9" x2="9" y2="15"></line>
+  `);
+}
+/** A "blocked" glyph (circle + diagonal slash) -- distinct from `errorIcon()`
+ *  since a denial is a policy rejection, not a runtime failure. */
+function deniedIcon() {
+    return icon(svg `<circle cx="12" cy="12" r="9"></circle><line x1="6" y1="18" x2="18" y2="6"></line>`);
+}
+const STATUS_ICON = {
+    pending: pendingIcon,
+    running: runningIcon,
+    success: successIcon,
+    error: errorIcon,
+    denied: deniedIcon,
+};
+/** Visible (not just color-coded) text for every status. */
+const STATUS_LABEL = {
+    pending: 'Pending',
+    running: 'Running',
+    success: 'Success',
+    error: 'Error',
+    denied: 'Denied',
+};
+/** `820` -> `"820ms"`; `1500` -> `"1.5s"`; `2000` -> `"2s"`. Sub-second
+ *  durations are the common case for a single tool call, so they get the
+ *  more precise unit; once a call runs a full second or longer, trimming to
+ *  (at most) one decimal place of seconds reads better than a 4-5 digit
+ *  millisecond count. Identical algorithm to lyra-tool-result-dialog's own
+ *  `formatDuration` -- duplicated rather than imported (these are two
+ *  independent, separately-consumable components; see this file's header
+ *  comment on the icon glyphs for the same rationale) but kept in lockstep
+ *  so the same call reports the same duration text in both places. */
+function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 1000) {
+        return `${Math.round(Math.max(0, ms))}ms`;
+    }
+    const seconds = ms / 1000;
+    const rounded = Math.round(seconds * 10) / 10;
+    return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)}s`;
+}
+/**
+ * `<lyra-tool-call-chip>` — a compact inline pill representing one tool/
+ * function call an agent made mid-conversation, e.g.
+ * `web_search: Searching web…` with a `running` spinner. It owns no detail
+ * surface of its own: clicking (or Enter/Space-activating) it only fires
+ * `lyra-tool-chip-select` — a consumer wires that to opening a
+ * `<lyra-tool-result-dialog>` (or anything else) at the call site. Keeping
+ * the two decoupled means a chip can be reused wherever a compact call
+ * summary is useful, with or without a detail surface behind it.
+ *
+ * The default slot is *not* the chip's visible content — the chip's own
+ * label is always built from `name`/`summary`/`status`/`duration-ms`. It's
+ * reserved for optional rich detail content (e.g. the tool's raw arguments,
+ * a short preview) shown in a floating tooltip on hover/focus, positioned
+ * with `internal/positioner.js`'s `place()` the same way `<lyra-combobox>`
+ * positions its listbox. No tooltip is shown at all when the slot carries no
+ * content — hovering an empty chip does nothing.
+ *
+ * The `icon` slot overrides the built-in per-status glyph entirely via the
+ * platform's own slot-fallback-content mechanism (`<slot
+ * name="icon">${fallback}</slot>` — the same pattern `<lyra-stat>`'s
+ * `caption` slot and `<lyra-file-input>`'s default slot already use):
+ * whatever is assigned to `slot="icon"` wins; otherwise the `icon` prop is
+ * rendered as a literal hint (e.g. an emoji); otherwise the built-in glyph
+ * for the current `status` is used.
+ *
+ * @customElement lyra-tool-call-chip
+ * @slot - Rich tooltip/detail content, shown on hover/focus. Nothing renders
+ * (no hover affordance at all) when this slot is empty.
+ * @slot icon - Overrides the built-in status glyph entirely.
+ * @event lyra-tool-chip-select - The chip was activated (click or Enter/Space
+ * while focused). `detail: { name, callId }`.
+ * @csspart base - The clickable pill (`<button>`).
+ * @csspart icon - Wrapper around the status glyph / `icon` slot.
+ * @csspart label - Wrapper around `category`, `name` and `summary`.
+ * @csspart category - The optional grouping label.
+ * @csspart name - The tool/function name.
+ * @csspart summary - The short status text.
+ * @csspart meta - Wrapper around `status-text` and `duration`.
+ * @csspart status-text - The visible text twin of the status glyph/color — carries the state in text, not just color.
+ * @csspart duration - The formatted `duration-ms`, when set.
+ * @csspart tooltip - The floating detail popup (only meaningful while open).
+ */
+export class LyraToolCallChip extends LyraElement {
+    constructor() {
+        super(...arguments);
+        /** The tool/function name, e.g. `web_search`. */
+        this.name = '';
+        /** Optional grouping label, e.g. `research`. */
+        this.category = '';
+        /** The call's current lifecycle state — drives the glyph, color, and `status-text`. */
+        this.status = 'pending';
+        /** Short human-readable status text, e.g. `Searching web…`. */
+        this.summary = '';
+        /** Literal icon hint (e.g. an emoji) used when the `icon` slot is empty — see the class doc's
+         *  icon-precedence note. Ignored once anything is assigned to `slot="icon"`. */
+        this.icon = '';
+        /** Unique identifier for this specific invocation — echoed back in `lyra-tool-chip-select`'s
+         *  detail so a listener can correlate the click with the call it fired for. */
+        this.callId = '';
+        // Same fix lyra-stat's hasIcon/lyra-combobox's hasHintSlot etc. already
+        // establish: a `[part]` always contains a literal `<slot>` child regardless
+        // of assigned content, so `:empty` never matches -- real emptiness is
+        // tracked in JS instead. Only element children count (mirrors lyra-stat's
+        // identical default-slot check) since the tooltip's rich content is
+        // expected to be markup, not a bare text node.
+        this.hasDetailSlot = false;
+        this.tooltipOpen = false;
+        this.onDetailSlotChange = (e) => {
+            this.hasDetailSlot = e.target.assignedElements({ flatten: true }).length > 0;
+        };
+        this.showTooltip = () => {
+            if (!this.hasDetailSlot || this.tooltipOpen)
+                return;
+            this.tooltipOpen = true;
+        };
+        // Unconditional on blur/mouseleave, with no "did the pointer move into the
+        // tooltip itself" check -- the default slot is documented as read-only
+        // preview content (raw args, a short snippet), not an interactive surface
+        // meant to retain focus/hover of its own, so this stays as simple as a
+        // native `title` attribute's show/hide instead of adding a second
+        // pointer-tracking region.
+        this.hideTooltip = () => {
+            if (!this.tooltipOpen)
+                return;
+            this.tooltipOpen = false;
+        };
+        this.onKeyDown = (e) => {
+            // The native <button> already handles Enter/Space activation on its
+            // own -- this only needs to cover dismissing the (non-native) tooltip,
+            // the same Escape-to-close convention every other popup in this library
+            // follows (see lyra-combobox's onKeyDown).
+            if (e.key === 'Escape' && this.tooltipOpen) {
+                e.stopPropagation();
+                this.hideTooltip();
+            }
+        };
+        this.onClick = () => {
+            this.emit('lyra-tool-chip-select', { name: this.name, callId: this.callId });
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    willUpdate() {
+        if (!this.hasUpdated) {
+            this.hasDetailSlot = Array.from(this.children).some((el) => !el.hasAttribute('slot'));
+        }
+    }
+    updated(changed) {
+        if (changed.has('tooltipOpen')) {
+            this.cleanupPositioner?.();
+            this.cleanupPositioner = undefined;
+            if (this.tooltipOpen) {
+                const anchor = this.renderRoot.querySelector('[part="base"]');
+                const tooltip = this.renderRoot.querySelector('[part="tooltip"]');
+                if (anchor && tooltip)
+                    this.cleanupPositioner = place(anchor, tooltip, { placement: 'top-start' });
+            }
+        }
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.cleanupPositioner?.();
+    }
+    get accessibleLabel() {
+        const parts = [this.name || 'Tool call'];
+        if (this.summary)
+            parts.push(this.summary);
+        parts.push(STATUS_LABEL[this.status]);
+        if (this.durationMs != null && Number.isFinite(this.durationMs))
+            parts.push(formatDuration(this.durationMs));
+        return parts.join(' — ');
+    }
+    render() {
+        const hasCategory = this.category.length > 0;
+        const hasSummary = this.summary.length > 0;
+        const hasDuration = this.durationMs != null && Number.isFinite(this.durationMs);
+        return html `
+      <button
+        part="base"
+        type="button"
+        aria-label=${this.getAttribute('aria-label') || this.accessibleLabel}
+        @click=${this.onClick}
+        @mouseenter=${this.showTooltip}
+        @mouseleave=${this.hideTooltip}
+        @focus=${this.showTooltip}
+        @blur=${this.hideTooltip}
+        @keydown=${this.onKeyDown}
+      >
+        <span part="icon" aria-hidden="true">
+          <slot name="icon">${this.icon ? this.icon : STATUS_ICON[this.status]()}</slot>
+        </span>
+        <span part="label">
+          <span part="category" ?hidden=${!hasCategory}>${this.category}</span>
+          <span part="name">${this.name || 'Tool call'}</span>
+          <span part="summary" ?hidden=${!hasSummary}>${this.summary}</span>
+        </span>
+        <span part="meta">
+          <span part="status-text">${STATUS_LABEL[this.status]}</span>
+          <span part="duration" ?hidden=${!hasDuration}>${hasDuration ? formatDuration(this.durationMs) : nothing}</span>
+        </span>
+      </button>
+      <div part="tooltip" role="tooltip" ?hidden=${!this.tooltipOpen}>
+        <slot @slotchange=${this.onDetailSlotChange}></slot>
+      </div>
+    `;
+    }
+}
+__decorate([
+    property()
+], LyraToolCallChip.prototype, "name", void 0);
+__decorate([
+    property()
+], LyraToolCallChip.prototype, "category", void 0);
+__decorate([
+    property({ reflect: true })
+], LyraToolCallChip.prototype, "status", void 0);
+__decorate([
+    property()
+], LyraToolCallChip.prototype, "summary", void 0);
+__decorate([
+    property({ type: Number, attribute: 'duration-ms' })
+], LyraToolCallChip.prototype, "durationMs", void 0);
+__decorate([
+    property()
+], LyraToolCallChip.prototype, "icon", void 0);
+__decorate([
+    property({ attribute: 'call-id' })
+], LyraToolCallChip.prototype, "callId", void 0);
+__decorate([
+    state()
+], LyraToolCallChip.prototype, "hasDetailSlot", void 0);
+__decorate([
+    state()
+], LyraToolCallChip.prototype, "tooltipOpen", void 0);
+defineElement('tool-call-chip', LyraToolCallChip);

package/dist/components/tool-call-chip/tool-call-chip.styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("lit").CSSResult;

package/dist/components/tool-call-chip/tool-call-chip.styles.js

@@ -0,0 +1,203 @@
+import { css } from 'lit';
+export const styles = css `
+  :host {
+    display: inline-flex;
+    max-inline-size: 100%;
+    /* Per-status accent -- one custom property swapped by the :host([status])
+       rules below rather than repeating background/color per part per status.
+       Defaults to the 'pending' tone so an unset/unknown status still reads
+       as neutral instead of unstyled. */
+    --lyra-tool-call-chip-accent: var(--lyra-color-text-quiet);
+    --lyra-tool-call-chip-bg: var(--lyra-color-surface);
+    --lyra-tool-call-chip-border: var(--lyra-color-border);
+  }
+
+  :host([status='running']) {
+    --lyra-tool-call-chip-accent: var(--lyra-color-brand);
+    --lyra-tool-call-chip-bg: var(--lyra-color-brand-quiet);
+    --lyra-tool-call-chip-border: transparent;
+  }
+  :host([status='success']) {
+    --lyra-tool-call-chip-accent: var(--lyra-color-success);
+    --lyra-tool-call-chip-bg: var(--lyra-color-success-quiet);
+    --lyra-tool-call-chip-border: transparent;
+  }
+  :host([status='error']) {
+    --lyra-tool-call-chip-accent: var(--lyra-color-danger);
+    --lyra-tool-call-chip-bg: var(--lyra-color-danger-quiet);
+    --lyra-tool-call-chip-border: transparent;
+  }
+  /* 'denied' reads as a policy rejection, not a runtime failure -- the
+     warning (not danger) tint keeps it visually distinct from 'error',
+     matching lyra-tool-result-dialog's identical status vocabulary/tone so
+     the two components agree on what "denied" looks like. */
+  :host([status='denied']) {
+    --lyra-tool-call-chip-accent: var(--lyra-color-warning);
+    --lyra-tool-call-chip-bg: var(--lyra-color-warning-quiet);
+    --lyra-tool-call-chip-border: transparent;
+  }
+
+  [part='base'] {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--lyra-space-xs);
+    max-inline-size: 100%;
+    box-sizing: border-box;
+    padding: 0.25rem var(--lyra-space-s);
+    border: 1px solid var(--lyra-tool-call-chip-border);
+    border-radius: 999px;
+    background: var(--lyra-tool-call-chip-bg);
+    color: var(--lyra-color-text);
+    font: inherit;
+    font-size: 0.8125rem;
+    line-height: 1.3;
+    text-align: start;
+    cursor: pointer;
+    -webkit-tap-highlight-color: transparent;
+    transition:
+      background-color var(--lyra-transition-fast),
+      border-color var(--lyra-transition-fast);
+  }
+  [part='base']:hover {
+    border-color: var(--lyra-color-brand);
+  }
+  [part='base']:focus-visible {
+    outline: var(--lyra-focus-ring-width) solid var(--lyra-focus-ring-color);
+    outline-offset: var(--lyra-focus-ring-offset);
+  }
+
+  [part='icon'] {
+    display: inline-flex;
+    flex: 0 0 auto;
+    align-items: center;
+    justify-content: center;
+    color: var(--lyra-tool-call-chip-accent);
+  }
+  [part='icon'] svg {
+    display: block;
+  }
+  /* A three-quarter arc (not a full ring) is what actually reads as
+     spinning once rotated -- a full circle looks identical at every
+     rotation frame. */
+  :host([status='running']) [part='icon'] svg {
+    animation: lyra-tool-call-chip-spin 1s linear infinite;
+  }
+  /* Subtler than the spin -- a slow opacity breathe, so a list of several
+     still-queued chips doesn't compete visually with any 'running' ones
+     next to it. */
+  :host([status='pending']) [part='icon'] svg {
+    animation: lyra-tool-call-chip-pulse 1.5s ease-in-out infinite;
+  }
+
+  [part='label'] {
+    display: inline-flex;
+    align-items: baseline;
+    gap: 0.3em;
+    flex: 1 1 auto;
+    min-inline-size: 0;
+    overflow: hidden;
+  }
+  [part='category'] {
+    flex: 0 0 auto;
+    /* Full-strength text, not --lyra-color-text-quiet -- this sits on top of
+       the per-status *-quiet tint backgrounds above (e.g. success-quiet),
+       and text-quiet's gray fails WCAG AA contrast against several of those
+       tints even though it comfortably passes against the plain surface
+       background used by the resting/denied states. */
+    color: var(--lyra-color-text);
+    font-size: 0.6875rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+  [part='category']::after {
+    content: '·';
+    margin-inline-start: 0.3em;
+  }
+  [part='name'] {
+    flex: 0 1 auto;
+    min-inline-size: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-weight: 600;
+  }
+  [part='summary'] {
+    flex: 1 1 auto;
+    min-inline-size: 3ch;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    /* See [part='category']'s comment above -- same contrast rationale. */
+    color: var(--lyra-color-text);
+  }
+  [part='summary']::before {
+    content: ': ';
+  }
+
+  [part='meta'] {
+    display: inline-flex;
+    flex: 0 0 auto;
+    align-items: baseline;
+    gap: 0.4em;
+    margin-inline-start: auto;
+    font-size: 0.6875rem;
+  }
+  [part='status-text'] {
+    color: var(--lyra-tool-call-chip-accent);
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    white-space: nowrap;
+  }
+  [part='duration'] {
+    /* See [part='category']'s comment above -- same contrast rationale. */
+    color: var(--lyra-color-text);
+    font-variant-numeric: tabular-nums;
+    white-space: nowrap;
+  }
+
+  /* Positioned by internal/positioner.js's place() -- see combobox's
+     [part='listbox'] for the identical fixed/z-index/max-size shape. Unlike
+     that popup this one has no open/close transition: a tooltip that
+     tracks the pointer/focus target benefits from appearing instantly, not
+     chasing a fade. */
+  [part='tooltip'] {
+    position: fixed;
+    z-index: 900;
+    box-sizing: border-box;
+    max-inline-size: min(90vw, 24rem);
+    padding: var(--lyra-space-s) var(--lyra-space-m);
+    background: var(--lyra-color-surface);
+    border: 1px solid var(--lyra-color-border);
+    border-radius: var(--lyra-radius);
+    box-shadow: var(--lyra-shadow);
+    font-size: 0.8125rem;
+    line-height: 1.4;
+    color: var(--lyra-color-text);
+  }
+
+  @keyframes lyra-tool-call-chip-spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+  @keyframes lyra-tool-call-chip-pulse {
+    0%,
+    100% {
+      opacity: 1;
+    }
+    50% {
+      opacity: 0.35;
+    }
+  }
+  @media (prefers-reduced-motion: reduce) {
+    [part='base'] {
+      transition: none !important;
+    }
+    :host([status='running']) [part='icon'] svg,
+    :host([status='pending']) [part='icon'] svg {
+      animation: none !important;
+    }
+  }
+`;

package/dist/components/tool-param-form/tool-param-form.d.ts

@@ -0,0 +1,145 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import '../select/select.js';
+import '../combobox/option.js';
+import '../checkbox/checkbox.js';
+/** The four leaf property types this phase's flat-schema renderer understands. */
+export type ToolParamFormPropertyType = 'string' | 'number' | 'integer' | 'boolean';
+/**
+ * One `schema.properties` entry. Deliberately shallow — see the class doc for
+ * the full scope limitation this type encodes.
+ */
+export interface ToolParamFormProperty {
+    type: ToolParamFormPropertyType;
+    /** A closed set of string choices, rendered as a `<lyra-select>`. Only meaningful when `type` is `'string'`. */
+    enum?: string[];
+    /** Helper text rendered under the field. */
+    description?: string;
+    /** Display label. Falls back to the property key itself when omitted. */
+    title?: string;
+    /** Pre-filled value used whenever `value` doesn't already have this key. */
+    default?: unknown;
+}
+/**
+ * The (intentionally flat) JSON Schema subset this component can render:
+ * a plain object whose every property is a string, number/integer, boolean,
+ * or string enum. See the class doc for what's out of scope.
+ */
+export interface ToolParamFormSchema {
+    type: 'object';
+    properties: Record<string, ToolParamFormProperty>;
+    required?: string[];
+}
+/**
+ * `<lyra-tool-param-form>` — renders one form control per top-level property
+ * of a JSON Schema object, for ad hoc tool invocation or approval-editing UIs
+ * (e.g. "the agent wants to call `create_event(title, attendees, allDay)` —
+ * let the user tweak the arguments before running it").
+ *
+ * **Scope limitation (intentional, not accidental):** this phase only
+ * understands a *flat* object schema — every `properties` entry must be
+ * `'string'`, `'number'`, `'integer'`, `'boolean'`, or a string `enum`.
+ * Nested objects, arrays, `oneOf`/`anyOf`/`allOf`, `$ref`, and any other
+ * JSON Schema keyword are not read. A full JSON-Schema-to-form renderer is
+ * out of scope for this component; a property whose `type` isn't one of the
+ * four above renders a visible "Unsupported field type" note instead of
+ * silently dropping it or throwing.
+ *
+ * Fields render in `Object.keys(schema.properties)` order (insertion order,
+ * which is reliable for a plain object's string keys). A field's label is
+ * `title ?? ` the property key; `description` renders as helper text below
+ * the control; a key listed in `required` gets a visible `*` and the
+ * underlying control's own `required` wiring.
+ *
+ * This component owns no Submit/Cancel/Approve chrome — a consumer composes
+ * it inside their own dialog (e.g. a tool-approval dialog) and reads
+ * `.value`/`.errors`/`checkValidity()` (or calls `reportValidity()` right
+ * before acting, which also reveals any inline errors that user interaction
+ * hasn't surfaced yet).
+ *
+ * `value` is exactly what the consumer last set it to — a field with no
+ * entry in `value` but a schema `default` displays (and is *emitted*, via
+ * `lyra-input`) as that default, but the `value` *property* itself is left
+ * alone until the user actually edits that field. This mirrors an
+ * uncontrolled `<input placeholder>` not writing to `.value`, and means the
+ * very first `lyra-input` a consumer receives already carries every default
+ * resolved, so round-tripping `e.detail.value` back into `.value` converges
+ * after one edit.
+ *
+ * Optional native `<form>` participation is implemented via `ElementInternals`
+ * attached directly (this component's value is a whole object, not a plain
+ * string, so the `FormAssociated` string-value mixin doesn't fit — same
+ * shape as `<lyra-combobox>`'s array-valued case). This is a nice-to-have
+ * layered on top of the primary integration contract (`value` +
+ * `lyra-input`/`lyra-validity-change`), not a requirement: a consumer that
+ * never puts this inside a `<form>` loses nothing.
+ *
+ * @customElement lyra-tool-param-form
+ * @event lyra-input - A field's value changed. `detail: { value }` — the
+ * full current value object (every property, defaults resolved), not just
+ * the field that changed.
+ * @event lyra-validity-change - Overall validity changed (a required field
+ * became empty/non-empty). `detail: { valid: boolean; errors: Record<string, string> }`.
+ * @csspart base - The outer wrapper around all fields.
+ * @csspart field - One property's wrapper (label + control + description + error).
+ * @csspart label - A field's label.
+ * @csspart description - A field's helper text, from `schema.description`.
+ * @csspart error - A field's inline validation message (only rendered once the field has been visited).
+ */
+export declare class LyraToolParamForm extends LyraElement {
+    static formAssociated: boolean;
+    static styles: import("lit").CSSResultGroup[];
+    schema: ToolParamFormSchema;
+    value: Record<string, unknown>;
+    /** Submission key for the optional native `<form>` participation — see the class doc. */
+    name: string;
+    disabled: boolean;
+    private _errors;
+    private touchedFields;
+    private internals;
+    private baseId;
+    private lastValidityKey;
+    constructor();
+    connectedCallback(): void;
+    /** `value`, with any property missing from it filled in from `schema`'s own `default` — see the class doc. */
+    get effectiveValue(): Record<string, unknown>;
+    /**
+     * The current per-field validation errors (`{ [propertyKey]: message }`),
+     * required-and-empty only — mirrors the last `lyra-validity-change`
+     * event's `errors`. Independent of which fields have been visited; a
+     * consumer wanting the visited-only, screen-reader-announced subset
+     * should read the rendered `[part="error"]` elements instead.
+     */
+    get errors(): Record<string, string>;
+    /** The current per-field validation errors (required-and-empty only), independent of `touchedFields`. */
+    private computeErrors;
+    /** Non-mutating validity check — unlike `reportValidity()`, never reveals inline errors. */
+    checkValidity(): boolean;
+    /**
+     * Reveals inline errors for every currently-invalid required field (as if
+     * each had been visited) and returns overall validity — the hook a
+     * consumer's own Submit/Approve button should call right before acting,
+     * mirroring a native `<form>`'s `reportValidity()`.
+     */
+    reportValidity(): boolean;
+    formResetCallback(): void;
+    formDisabledCallback(disabled: boolean): void;
+    protected willUpdate(changed: PropertyValues): void;
+    /** Pushes `effectiveValue`/`errors` into `ElementInternals` — see the class doc's form-participation note. */
+    private syncInternals;
+    protected updated(changed: PropertyValues): void;
+    private setFieldValue;
+    private markTouched;
+    private onTextInput;
+    private onNumberInput;
+    private onSelectChange;
+    private onCheckboxChange;
+    private renderControl;
+    private renderField;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-tool-param-form': LyraToolParamForm;
+    }
+}