import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraSize}from'../../../internal/variants.js';import{type FormOwnerValue}from'../../../internal/form-associated.js';import{type LyraFormValidator}from'../form-validator.js';export interface LyraCheckboxEventMap{input:Event;change:Event;'lr-input':CustomEvent<{checked:boolean;}>;'lr-change':CustomEvent<{checked:boolean;}>;focus:FocusEvent;blur:FocusEvent;'lr-invalid':CustomEvent<null>;'lr-checkbox-toggle-request':CustomEvent<{checked:boolean;}>;}
/**
* `<lr-checkbox>` — a boolean form control. Structurally the same idea as
* `<lr-switch>` (form-associated via `ElementInternals`, click and
* Space both toggle) but with checkbox semantics: `role="checkbox"` +
* an `aria-checked` that can also be `"mixed"`, and a visual box/checkmark
* instead of a track/thumb.
*
* `checked` is not a plain string, so this attaches `ElementInternals`
* directly and implements its own `updateValidity()` rather than using the
* `FormAssociated` mixin — see `<lr-combobox>` for the same
* direct-`ElementInternals` shape with a non-string value.
*
* Supporting text is optional through either Web Awesome's `hint` spelling or Shoelace's
* `help-text` spelling. `errorText` and the `error` slot provide the matching owned error surface;
* all rendered messages share an additive described-by relationship with external host ids.
* Deliberately no separate top-of-field label property/slot/part: the default slot already is the
* visible, clickable checkbox label, matching `lr-switch`'s form-control shape.
* Default-slot presence follows flattened rendered assignment and updates when forwarded content
* changes. Visual elements, including decorative `aria-hidden` icons, keep the label wrapper;
* accessible naming remains the browser's slot semantics unless a host `aria-label` is present.
* The public label and supporting/error text wrap at arbitrary boundaries in constrained rows;
* the fixed checkbox square and shared interactive target never shrink to make that fit.
* The internal checkbox role exposes explicit stateful `aria-invalid`: visible error chrome wins
* immediately, while intrinsic/custom invalidity is exposed only after user interaction.
*
* Removing `error-text` safely omits the message while preserving native null property readback.
* Explicit empty text stays empty; later supplied text renders normally.
*
* @customElement lr-checkbox
* @slot - Label text, rendered next to the box. Clicking it toggles the
* checkbox, the same as clicking a native checkbox's associated `<label>`.
* If left empty, set `aria-label` on the host so the control still has an accessible name. Host
* `aria-label` is forwarded by presence, including an explicitly empty value. Interactive label
* content remains a separate focus stop outside the checkbox role; activating that content does
* not also toggle the checkbox.
* @slot hint - Web Awesome-compatible supporting text.
* @slot help-text - Shoelace-compatible supporting text; the same surface as `hint`.
* @slot error - Custom error content on the owned error surface.
* A host `aria-describedby` attribute is resolved onto the internal `role="checkbox"` through
* `ariaDescribedByElements` so externally-owned descriptions remain valid across the shadow
* boundary.
* @event input - The user toggled the checkbox; bubbling and composed like a native form event.
* @event lr-input - Prefixed compatibility alias for `input`; `detail: { checked }`.
* @event change - Fired immediately after `input` for the same user toggle.
* @event lr-change - Compatibility alias fired after `input` and `change` (click or Space).
* `detail: { checked }`. Not fired for a programmatic `.checked` assignment, nor for a user toggle
* a listener refused through `lr-checkbox-toggle-request`.
* @event lr-checkbox-toggle-request - A user toggle (click or Space) is about to change `checked`;
* `detail: { checked }` carries the state the control *would* take, and `checked` itself still
* holds the old value while this dispatches. Cancelable: calling `preventDefault()` keeps the
* current state, so the control never flips at all rather than flipping and snapping back, and
* none of `input`/`lr-input`/`change`/`lr-change` fire. A listener may instead resolve the request
* by assigning `checked` itself during the dispatch, which suppresses the built-in write the same
* way. Not fired for a programmatic `.checked` assignment, nor while the control is disabled. An
* `<lr-checkbox-group>` owner consumes this event and republishes it as its own
* `lr-checkbox-group-toggle-request`, the same way it already translates `input`/`change`.
* @event focus - Re-dispatched from the internal control as a bubbling, composed event.
* @event blur - Re-dispatched from the internal control as a bubbling, composed event.
* @event lr-invalid - The checkbox failed a validity check. Cancelable: calling
* `preventDefault()` also cancels the native `invalid` event behind it, suppressing the
* browser's own validation bubble so an app can present the failure its own way.
* @cssstate required - Matches while `required` is set. Style with `lr-checkbox:state(required)`.
* @cssstate optional - Matches while `required` is not set — the complement of `required`.
* @cssstate valid - Matches while the control satisfies its constraints, including any
* `setCustomValidity()` error.
* @cssstate invalid - Matches while it does not — from the very first render, before the user has
* touched anything.
* @cssstate user-valid - `valid`, but only after the user has interacted: a toggle the host
* allowed, a blur, `reportValidity()`, or a submission attempt. Not after a silent
* `checkValidity()` alone. A toggle refused through `lr-checkbox-toggle-request` is deliberately
* not one of them -- nothing changed, so nothing is revealed until the user interacts again.
* @cssstate user-invalid - `invalid` after that same interaction. Style validation errors with this
* rather than `invalid`: a pristine required checkbox is genuinely invalid, but colouring it red
* before the user has done anything is hostile.
* @cssstate checked - Matches while the live checked state is true.
* @cssstate disabled - Matches while disabled directly or by an ancestor fieldset.
* @cssstate indeterminate - Matches while the visual mixed state is true.
* @csspart form-control - The outer wrapper around the checkbox, error, and hint.
* @csspart row - The row wrapping the checkbox owner and the label as siblings. This is the node
*  to size or align when laying out a column of checkboxes; `base`/`checkbox` is only the control
*  box inside it, so its inline size tracks the box, not the row.
* @csspart base - Compatibility name for the interactive control; use `checkbox`.
* @csspart checkbox - The interactive `role="checkbox"` owner around the box. It is the same node
*   as `base`, retains the shared `--lr-icon-button-size` minimum target at every size tier, and
*   keeps the rich default label as a sibling so nested actions remain valid focus stops.
* @csspart box - The small square that shows the checkmark/indeterminate dash.
* @csspart control - WA/Shoelace name for `box`.
* @csspart control--checked - Shoelace state alias on the control while checked.
* @csspart control--indeterminate - Shoelace state alias on the control while indeterminate.
* @csspart checkmark - Lyra name for the visible glyph inside the box.
* @csspart checked-icon - WA/Shoelace name for the checked glyph.
* @csspart indeterminate-icon - WA/Shoelace name for the indeterminate glyph.
* @csspart label - The wrapper around the default slot.
* @csspart hint - Web Awesome name for the supporting-text wrapper.
* @csspart form-control-help-text - Shoelace name for the same supporting-text wrapper.
* @csspart error - The error message.
* @cssprop [--lr-checkbox-label-indent=calc(var(--lr-checkbox-box-size) + var(--lr-space-s))] -
* The inline distance from the control's start edge to the start of the label text, i.e. the box's
* own floor plus the gap next to it — so it tracks `size` along with the box. Published so a
* consumer composing per-option hint text under the label can align it without re-deriving that
* formula from the shadow styles, and used as the source of the real gap so the two cannot drift.
* Setting it on the element (or on `lr-checkbox` in your own stylesheet) moves the label; because
* custom properties inherit down and not sideways, it is *not* readable from a sibling node in your
* tree — align a sibling by computing the same formula from `--lr-theme-icon-button-size`,
* `--lr-theme-form-control-height-*` and `--lr-theme-space-s`, which you control.
* @cssprop [--lr-checkbox-checked-bg=var(--lr-color-brand)] - Background of `[part='box']` while
* `checked` or `indeterminate`. Retint just this control's checked fill without touching the shared
* `--lr-color-brand` token every other component also reads.
* @cssprop [--lr-checkbox-checked-border=var(--lr-color-brand)] - Border color of `[part='box']`
* while `checked` or `indeterminate`.
* @cssprop [--lr-checkbox-hover-border=var(--lr-color-brand)] - Box border while the enabled
* interactive control is hovered.
* @cssprop [--lr-checkbox-active-border=var(--lr-color-brand)] - Box border while pressed.
* @cssprop [--lr-checkbox-active-ring=var(--lr-color-brand-quiet)] - Outer box ring while pressed.
* @cssprop [--lr-checkbox-invalid-border=var(--lr-color-danger)] - Box border while invalid chrome
* is visible.
* @cssprop [--checked-icon-color=currentColor] - WA-compatible color of the checked or
* indeterminate glyph.
* @cssprop [--checked-icon-scale=1] - WA-compatible scale of the checked or indeterminate glyph.
* @cssprop [--lr-checkbox-box-size=min(var(--lr-icon-button-size), calc(var(--lr-form-control-height) * 0.7))] -
* Edge length of `[part='box']`. Derived from the `size` tier's shared control height, so the box
* lines up with an `<lr-input>`/`<lr-select>`/`<lr-button>` of the same `size`; set it to pin the box
* independently of the tier.
* @status stable
* @since 4.0.0
*/
export declare class LyraCheckbox extends LyraElement<LyraCheckboxEventMap>{
/** Public WA-compatible intrinsic validator catalog. */
static get validators():LyraFormValidator<LyraCheckbox>[];static styles:import("lit").CSSResultGroup[];static formAssociated:boolean;static properties:{customError:{attribute:string;reflect:boolean;noAccessor:boolean;};checked:{attribute:boolean;noAccessor:boolean;};defaultChecked:{attribute:string;type:BooleanConstructor;reflect:boolean;useDefault:boolean;noAccessor:boolean;};indeterminate:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};disabled:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};name:{reflect:boolean;noAccessor:boolean;converter:import("lit").ComplexAttributeConverter<string,unknown>;};required:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};size:{reflect:boolean;};value:{reflect:boolean;noAccessor:boolean;};};
/**
* Control size, on the library's shared ladder. Accepts both spellings of every tier —
* `2xs`/`xs`/`s`/`m`/`l`/`xl` and Web Awesome's `small`/`medium`/`large` — so migrating either way
* is a tag rename. Scales the box and its checkmark off the same `--lr-form-control-*` values
* `<lr-input>`/`<lr-select>`/`<lr-button>` use, so controls of one `size` line up in a row. The
* slotted label keeps the library's standard control-label type size at every tier; restyle it
* through `::part(label)` if you want it to track the control.
*/
size:LyraSize;
/** Web Awesome supporting text. It wins when both mapped spellings are supplied. */
hint:string;
/** Shoelace alias for {@link hint}. */
helpText:string;
/** Error text associated with the inner checkbox; custom markup can use the `error` slot. */
errorText:string;private hasLabelSlot;private hasHintSlot;private hasHelpTextSlot;private hasErrorSlot;private touched;
/** Whether the user has acted on this control yet, which is what gates the `user-valid`/
*  `user-invalid` custom states. Deliberately separate from `touched` (which drives the visible
*  `data-invalid`/`aria-invalid` pair and is set on blur alone): a toggle is an interaction the
*  instant it happens, and so is interactive validation — `reportValidity()` and a submission
*  attempt alike, via `installInteractionOnInvalid()` — exactly as it does for native
*  `:user-invalid`. A silent `checkValidity()` alone never counts. Not `@state`: nothing in
*  `render()` reads it. */
private hasInteracted;private internals;private validityController;
/** Consumer-supplied validation message reflected through `custom-error`. */
customError:string|null;private labelObserver?;private hasSyncedDescribedByElements;private _defaultChecked;private _checkedDirty;private settingDefaultChecked;private reflectingDefaultChecked;private _fieldsetDisabled;private _groupDisabled;private _name;private _checked;private _indeterminate;private _disabled;private _required;private _value;private toggleGuard;
/** Whether the control is disabled explicitly, by an ancestor fieldset, or by an owning `<lr-checkbox-group>`. */
get effectiveDisabled():boolean;get checked():boolean;set checked(next:boolean);
/** Reflected current reset default; changing it never overwrites dirty live `checked` state. */
get defaultChecked():boolean;set defaultChecked(next:boolean);get indeterminate():boolean;set indeterminate(next:boolean);
/** Keeps an owning aggregate's value/FormData/validity coherent in the same task as a direct
* child property write. User events remain the group's separate public notification boundary. */
private notifyOwningGroup;get disabled():boolean;set disabled(next:boolean);
/** The form submission key, reflected synchronously for native form APIs. */
get name():string;set name(next:string|null);get required():boolean;set required(next:boolean);get value():string;set value(next:string|null);constructor();get form():HTMLFormElement|null;set form(owner:FormOwnerValue);getForm():HTMLFormElement|null;get labels():NodeList;get validity():ValidityState;get validationMessage():string;get willValidate():boolean;connectedCallback():void;
/**
* Whether a direct light-DOM child carries `slot="name"` -- the same structural check
* {@link refreshNamedSlotState} always relied on for the connect/reconnect pass, and now also
* what the hint/help-text/error slotchange handlers use. `HTMLSlotElement.assignedElements()` is
* a live re-derivation of the browser's *current* slot-assignment computation, and WebKit has
* been observed reporting it transiently empty for an unrelated forwarding-slot chain nested
* inside the assigned element (a deeply forwarded node's own `characterData` mutating can fire a
* spurious `slotchange` on this outer named slot, with `assignedElements()` reporting zero for
* that one notification) -- even though the assigned child's own `slot` attribute never changed.
* Reading the light-DOM attribute directly is immune to that: it does not depend on the engine's
* live slot-assignment snapshot at all.
*/
private hasLightDomChildWithSlot;private refreshNamedSlotState;disconnectedCallback():void;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;
/** Shared with every other form control: disabled (own, fieldset, or group) bars validation. */
private get barredFromValidation();private updateValidity;private reflectInvalid;private syncFormState;formResetCallback():void;formStateRestoreCallback(state:string|File|FormData|null,reason:'autocomplete'|'restore'):void;private restoreCheckedFromDefault;formDisabledCallback(disabled:boolean):void;private markInteracted;checkValidity():boolean;reportValidity():boolean;
/**
* Sets or clears a consumer-supplied validation error — the standard channel for a server-side
* rejection ("those terms have been superseded") that no client-side constraint can express. A
* non-empty `message` raises `customError` and becomes `validationMessage`, so the control fails
* `checkValidity()`, blocks form submission, and matches `:state(invalid)`; `''` clears it.
*
* Clearing restores the control's own computed validity rather than forcing it valid: a
* required-and-unchecked checkbox whose custom error is cleared stays `valueMissing`. The custom
* error also survives every intrinsic recomputation in between (each toggle re-runs
* `updateValidity()`) and a form reset, exactly like a native control — only another
* `setCustomValidity('')` clears it.
*
* The message is caller-supplied content, so it is used verbatim and never localized here.
*/
setCustomValidity(message:string):void;
/** Clears consumer-supplied validity and restores the current required/checked constraint. */
resetValidity():void;
/** Activates the internal checkbox control (toggling it), mirroring `<lr-button>`'s host
*  `click()` forwarding -- `HTMLElement.prototype.click()` is otherwise a no-op on a custom
*  element with no native click semantics of its own. */
click():void;
/** Moves focus to the internal checkbox control. */
focus(options?:FocusOptions):void;
/** Removes focus from the internal checkbox control. */
blur():void;private toggle;private onClick;private onKeyDown;private onSlotChange;private onHintSlotChange;private onHelpTextSlotChange;private onErrorSlotChange;private isDefaultLabelNode;private labelForwardingSlots;private observeLabelNode;private bindLabelObserverTargets;private handleLabelSlotChange;private onLabelSlotChange;private recomputeHasLabelSlot;private onBlur;private onFocus;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-checkbox':LyraCheckbox;}}