import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement,type LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import'../../forms/select/select.class.js';import'../../forms/combobox/option.class.js';import'../../forms/input/number-input.class.js';import{type FormOwnerValue}from'../../../internal/form-associated.js';
/** The four leaf property types this flat-schema renderer understands. */
export type ToolParamFormPropertyType='string'|'number'|'integer'|'boolean';export type ToolParamFormPrimitive=string|number|boolean;
/**
* One `schema.properties` entry. Deliberately shallow — see the class doc for
* the full scope limitation this type encodes.
*/
export interface ToolParamFormProperty{readonly type:ToolParamFormPropertyType;
/** A closed set of string choices, rendered as a `<lr-select>`. Only meaningful when `type` is `'string'`. */
readonly enum?:readonly string[];
/** Helper text rendered under the field. */
readonly description?:string;
/** Display label. Falls back to the property key itself when omitted. */
readonly title?:string;
/** Pre-filled value used whenever `value` doesn't already have this key. */
readonly default?:unknown;
/** Exact primitive value required when the property is present. */
readonly const?:ToolParamFormPrimitive;
/** Native editing-assistance hints forwarded when this property renders a text input. */
readonly autocomplete?:string;readonly spellcheck?:boolean;readonly autocapitalize?:string;readonly autoCorrect?:string;readonly inputMode?:string;readonly enterKeyHint?:string;}
/**
* 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 FlatToolParamSchema{readonly type:'object';readonly properties:Readonly<Record<string,ToolParamFormProperty>>;readonly required?:readonly string[];}export type ToolParamFormValue=Readonly<Record<string,unknown>>;export interface LyraToolParamFormEventMap{'lr-invalid':CustomEvent<null>;'lr-validity-change':CustomEvent<LyraEventDetailSnapshot<{readonly valid:boolean;readonly errors:Readonly<Record<string,string>>;}>>;'lr-input':CustomEvent<LyraEventDetailSnapshot<{readonly value:ToolParamFormValue;}>>;blur:CustomEvent<null>;focus:CustomEvent<null>;}
/**
* `<lr-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 renderer only
* understands a *flat* object schema — every `properties` entry must be
* `'string'`, `'number'`, `'integer'`, `'boolean'`, or a string `enum`;
* primitive `const` is also enforced. Nested objects, arrays,
* `oneOf`/`anyOf`/`allOf`, `$ref`, constraints such as `minLength`/`minimum`,
* and schema-valued `additionalProperties` 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 and marks the
* form invalid instead of silently dropping it or throwing.
* A schema is additionally bounded to 100 fields and 500 enum choices per field. Exceeding either
* ceiling fails the form closed with a localized form-wide error while the bounded prefix remains
* available for inspection; malformed null/array property definitions fail as schema errors rather
* than being misreported as value-serialization failures.
*
* 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 `*`. The outer component owns validation
* because JSON Schema `required` means property presence, unlike HTML controls' nonempty/must-check
* semantics. Boolean fields therefore expose explicit unset/true/false values instead of
* conflating an absent property with `false`.
*
* Deliberately no top-level `label`/`hint`/`errorText` chrome (unlike
* `<lr-checkbox-group>`'s own trio, despite both being compound, multi-item
* form controls): every field already carries its own per-field
* `label`/`description`/`error` parts above, and this whole control is
* meant to be composed inside a consumer's own dialog/section (e.g. "Approve
* `create_event` call?") that already supplies the surrounding heading and
* context — a second, redundant outer label here would just repeat it. A
* form-wide validation summary is still available via the `error` part
* (`class="form-error"`), driven by `reportValidity()`.
* The `base` wrapper is always the accessible `role="group"`, so a native external `<label for>`
* pointing at this form-associated host can name it via the external-label bridge. A host
* `aria-label` wins by attribute presence (including an explicitly empty value), forwarded onto
* that same `base` wrapper — matching `<lr-rubric-form>`'s identical pattern. Every generated field
* retains its own more specific name either way.
*
* 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
* `lr-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 `lr-input` a consumer receives already carries every default
* resolved, so round-tripping `e.detail.value` back into `.value` converges
* after one edit. JSON Schema defines `default` as an annotation; this form
* renderer deliberately materializes it before validation and submission,
* so a valid default can satisfy `required` here.
*
* 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 `<lr-combobox>`'s array-valued case). This is a nice-to-have
* layered on top of the primary integration contract (`value` +
* `lr-input`/`lr-validity-change`), not a requirement: a consumer that
* never puts this inside a `<form>` loses nothing.
* The value present on first connection is cloned as the native default.
* `form.reset()` restores a fresh clone of that default, clears touched and
* interaction state, and preserves any consumer-set custom validity message,
* matching native controls' separation between reset state and custom errors.
*
* @customElement lr-tool-param-form
* @event lr-input - A field's value changed. `detail: { value }` — the
* full current value object (every property, defaults resolved), not just
* the field that changed.
* @event lr-validity-change - Effective native validity or errors changed. The frozen
* `detail: { valid, errors }` includes custom errors and own/fieldset validation barring.
* @event focus - Re-dispatched when a generated native `'string'` text input receives focus.
* Composed controls (`<lr-select>`, `<lr-number-input>`) already expose their own bubbling,
* composed bridge.
* @event blur - Re-dispatched when a generated native `'string'` text input loses focus.
* @event lr-invalid - The complete parameter form failed a validity check. Cancelable;
* preventing it also prevents the native `invalid` event's default validation UI.
* @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 control - The native `<input>` for a `'string'` (non-enum) field, or the composed
* `<lr-number-input>` for a `'number'`/`'integer'` field (its own increment/decrement steppers
* replace the field type's native spin buttons — see `<lr-number-input>`'s own docs for its
* further-forwarded parts). Not present on the `'boolean'`/enum (`<lr-select>`) or
* unsupported-type fallback branches.
* @csspart description - A field's helper text, from `schema.description`.
* @csspart error - A field-level or form-level validation message.
* @csspart unsupported - The fallback note rendered in place of a control for
* a property whose `type` is outside this renderer's scope.
* @csspart empty - The message shown when `schema.properties` has no entries.
* @cssprop [--lr-form-control-required-content=' *'] - The required-field marker rendered after the
* `label` part of every field whose key is listed in the schema's `required` array — per field
* here, not per host, because this control's value is a whole object. Set it to `''` to suppress
* the marker, or to any other quoted string (`' (required)'`, a localized word) to replace it.
* Caller-supplied content, so it is never localized here.
* @cssprop [--lr-form-control-required-color=var(--lr-color-danger)] - Color of that marker,
* retunable without touching any other danger-coloured surface.
* @cssprop [--lr-form-control-required-offset=0] - Inline space between the label text and the
* marker.
* @cssprop [--lr-tool-param-form-invalid-border-color=var(--lr-color-danger)] - Border color of
* an invalid generated native text or number input.
* @cssstate required - The schema declares at least one required property. Requiredness is
* per-property here (the value is an object), so this is the whole-control reading: "this form
* demands something of the user".
* @cssstate optional - The schema declares no required property.
* @cssstate valid - Every field currently satisfies the supported schema subset, whether or not the
* user has touched anything.
* @cssstate invalid - At least one field, or the schema shape itself, is currently in error.
* @cssstate user-valid - `valid`, and the user has interacted: edited a field, left one,
* `reportValidity()`, or a submission attempt. Not after a silent `checkValidity()` alone.
* @cssstate user-invalid - `invalid`, and the user has interacted. A pristine required field is
* invalid but deliberately does not match this, so a consumer's `:state(user-invalid)` styling
* cannot paint the form red before the user has typed anything. A form reset makes it pristine
* again.
* @status stable
* @since 4.0.0
*/
export declare class LyraToolParamForm extends LyraElement<LyraToolParamFormEventMap>{static formAssociated:boolean;static styles:import("lit").CSSResultGroup[];protected static readonly immutableEventDetails:readonly string[];static properties:{customError:{attribute:string;reflect:boolean;noAccessor:boolean;};name:{reflect:boolean;noAccessor:boolean;};schema:{attribute:boolean;noAccessor:boolean;};value:{attribute:boolean;noAccessor:boolean;};disabled:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};};private _errors;private _formError;private showFormError;private touchedFields;private internals;private validityController;
/** Consumer-supplied validation message reflected through `custom-error`. */
customError:string|null;private baseId;private _fieldsetDisabled;private _name;private _schema;private schemaInputShapeError;private schemaInputExceededLimits;private _value;private valueInputInvalid;private valueInputTruncated;private defaultValueSnapshot;private defaultValueCaptured;private _effectiveValue;private _validityFlags;private _disabled;private lastValidityKey;private hasInteracted;private errorAnnouncementSink?;private visibleErrorSnapshot;private suppressNextErrorAnnouncement;constructor();get form():HTMLFormElement|null;set form(owner:FormOwnerValue);
/** Returns the browser-resolved owning form, including an external owner selected by `form`. */
getForm():HTMLFormElement|null;get labels():NodeList;get validity():ValidityState;get validationMessage():string;get willValidate():boolean;private firstInvalidField;private get missingRequiredKeys();private firstMissingPropertyError;private focusFirstControl;
/** Forwards host clicks to the first rendered form field so the component behaves like a regular
*  control from caller code and event re-dispatch paths.
*/
click():void;connectedCallback():void;disconnectedCallback():void;
/** `value`, with any property missing from it filled in from `schema`'s own `default` — see the class doc. */
get effectiveValue():ToolParamFormValue;private get schemaProperties();private get requiredKeys();private resolveEffectiveValue;
/** Detached, deeply frozen schema snapshot. At most 100 fields, 100 required keys, and 500 enum
* choices per field are retained. Oversized assignments remain invalid until replaced; reassign
* the schema after changing it. */
get schema():FlatToolParamSchema;set schema(next:FlatToolParamSchema);
/** Detached, deeply frozen argument snapshot, bounded to 10,000 entries per array/plain record,
* 50,000 total nodes, and 16 nested levels. Reassign after changing it. */
get value():ToolParamFormValue;set value(next:ToolParamFormValue);
/** Submission key for the optional native `<form>` participation, reflected synchronously. */
get name():string;set name(next:string);get disabled():boolean;set disabled(next:boolean);
/** Whether the form is disabled explicitly or by an ancestor fieldset. */
get effectiveDisabled():boolean;
/** The current effective validation errors. Intrinsic errors are keyed by their property;
* a whole-control or caller-supplied custom error is keyed by the `base` part. */
get errors():Readonly<Record<string,string>>;private publicValidityErrors;private publishValiditySnapshot;
/** A schema-wide or JSON-serialization error that cannot be assigned to one field. */
get formError():string;
/**
* Computes the supported flat JSON Schema subset against the exact value
* that will be submitted. Defaults are already materialized in `effective`.
*/
private computeValidation;private markInteracted;
/** Resynchronizes validity without revealing inline errors. */
checkValidity():boolean;
/**
* Reveals every current field/root error (as if each field 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;
/**
* Sets or clears a consumer-supplied validation error — the standard channel for a rejection the
* schema cannot express ("the tool rejected these arguments"). A non-empty `message` raises
* `customError` and becomes `validationMessage`, so the form fails `checkValidity()`, blocks
* submission, and matches `:state(invalid)`; `''` clears it.
*
* Two layers, not one: this control already raises `customError` intrinsically for a malformed
* schema or an unsupported field type, and `setCustomValidity('')` clears only the consumer's own
* layer — a still-malformed schema stays invalid, with its own message restored. Clearing
* likewise never forces a form with an unmet `required` property valid, and the consumer's error
* survives every intrinsic recomputation in between (each field edit re-runs `syncFormState()`)
* and a `form.reset()`, matching a native control.
*
* Whole-control state: the message is exposed as `errors.base`, keyed to this control's `base`
* part. It is caller-supplied content, so it is used verbatim and never localized here.
*/
setCustomValidity(message:string):void;formResetCallback():void;formStateRestoreCallback(state:string|File|FormData|null,_mode?:'restore'|'autocomplete'):void;formDisabledCallback(disabled:boolean):void;private schemaShapeError;private serializeEffectiveValue;
/**
* Shared with every other form control in the library: own `disabled` and a `<fieldset disabled>`
* ancestor both bar constraint validation, so a barred form reports no failure and publishes
* neither `:state(invalid)` nor `:state(user-invalid)` — see `internal/custom-states.ts`.
*/
private get barredFromValidation();
/** Pushes the already-computed snapshot into `ElementInternals`. */
private syncInternals;
/**
* Publishes the current constraint state. Split out of {@linkcode syncInternals} because
* becoming (or ceasing to be) barred changes the answer without changing the submitted value.
*/
private applyValidity;
/**
* Republishes the six `:state()` validity hooks — see `internal/custom-states.ts`. Called from
* `syncInternals()` (so every validity recomputation carries them) and from `markTouched()` (the
* one interaction that changes the answer without touching validity).
*
* `required` here means "the schema declares at least one required property", which is the only
* whole-control reading available: this control's value is an object, so requiredness is per
* property, and a consumer styling `lr-tool-param-form:state(required)` is asking "does this form
* demand anything of the user".
*/
private syncValidityCustomStates;private syncFormState;protected updated(changed:PropertyValues):void;private setFieldValue;private markTouched;private onTextInput;private onNumberInput;private onSelectChange;private onBooleanSelectChange;private stopNestedControlEvent;private onFieldFocus;private onFieldBlur;private renderControl;private renderField;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-tool-param-form':LyraToolParamForm;}}