import type{ReactiveController,ReactiveControllerHost}from'lit';
/**
* How an external `<label>` activation reaches a control.
*
* `'focus'` is the native text/select-like behaviour: clicking the label moves focus to the
* control and nothing else happens. `'activate'` is the native toggle/button-like behaviour:
* focus moves *and* the control's own activation runs exactly once (a checkbox toggles, a
* `type="submit"` button submits).
*
* A closed literal union rather than an `enum`: `enum` is nominal, so a consumer could not write
* the string form, and it would ship a runtime object against the tree-shaking budget.
*/
export type ExternalLabelActivation='focus'|'activate';
/** Internal transactions used when the form control host itself owns the role and focus.
*
* Most controls put their semantic owner in shadow DOM, where the label bridge can distinguish an
* authored host `aria-label` from the internal target it manages. Host-owned controls cannot make
* that distinction from the attribute alone: their generated fallback, an external-label bridge
* name, and an authored override all occupy the same attribute. This protocol lets the component
* identify authored input and lets bridge writes pass through the component's own observation
* guard. It also makes release an explicit transaction, so a component can stop protecting the
* external name even when an author replaced the attribute before release ran.
*/
export type ExternalLabelHostSemanticOperation={readonly type:'has-authored-name';}|{readonly type:'apply';readonly name:string;}|{readonly type:'release';readonly appliedName:string;readonly hadPrevious:boolean;readonly previous:string|null;};
/** Opt-in protocol for a form control whose host owns its role, name, and focus. */
export declare const EXTERNAL_LABEL_HOST_SEMANTICS:unique symbol;
/** A host-owned semantic control participating in the guarded label-name protocol. */
export interface ExternalLabelHostSemanticOwner{}
/** The host surface {@linkcode ExternalLabelController} reads. Every member is optional because
*  the same controller serves controls built on the `FormAssociated` mixin, controls that drive
*  `ElementInternals` directly, and any environment whose DOM stops short of `attachInternals()`
*  altogether. */
export interface ExternalLabelHost extends HTMLElement{readonly renderRoot?:DocumentFragment|HTMLElement;readonly effectiveDisabled?:boolean;readonly disabled?:boolean;}interface AssociationRootSubscription{update(labels:readonly HTMLLabelElement[]):void;disconnect():void;}
/** Whether `label` names `host` in the DOM tree *right now*.
*
* Some engines update `ElementInternals.labels` only when mutation observers deliver. Label click
* handling runs before that checkpoint, so relying on the otherwise-live list can activate the
* control a `for` attribute named one mutation ago. Resolve the simple platform association rule
* structurally here; `getElementById()` also preserves the first-match rule for duplicate IDs. */
export declare function isCurrentlyAssociatedLabel(label:HTMLLabelElement,host:HTMLElement):boolean;
/** Subscribes one control to the shared, root-indexed external-label association observer. */
export declare function observeExternalLabelAssociations(host:HTMLElement,listener:()=>void):AssociationRootSubscription;
/**
* The label elements associated with `host`.
*
* `ElementInternals.labels` is the platform's own answer for a form-associated custom element — it
* already resolves both `<label for>` and an ancestor `<label>`, stays live as the document
* changes, and needs no id at all for the implicit form. It is feature-detected rather than
* assumed: a DOM shim's stand-in internals report an empty list, and an environment with no
* `attachInternals()` has none, so the `label[for]` query is kept as the degraded path rather than
* as the primary one.
*/
export declare function resolveExternalLabels(host:ExternalLabelHost):HTMLLabelElement[];
/**
* The accessible name contributed by `labels`, joined the way multiple native labels are: each
* label's own text, in document order, separated by a single space. Whitespace-only labels drop
* out entirely so an empty `<label>` cannot blank a real one.
*
* `host` is excluded from the text, because an implicit label *wraps* the control it names —
* `<label>Remember me <lr-checkbox>Yes</lr-checkbox></label>` names the checkbox "Remember me",
* not "Remember me Yes". Reading the label's whole `textContent` would fold the control's own
* content back into its name, which for a checkbox or a radio is precisely the text it already
* renders.
*/
export declare function resolveExternalLabelText(labels:readonly HTMLLabelElement[],host?:Node):string;
/**
* Bridges a native external `<label>` onto a form-associated custom element.
*
* A `<label for>` pointing at a custom element gives the platform *half* the relationship: the
* browser resolves `ElementInternals.labels` and forwards a click to the host, but it can reach no
* further. It cannot name the element inside the shadow root that actually owns the control's role
* — an accessible name is only announced on the node the user is focused on, and that node is
* never the host — and the forwarded host click lands on an element with no activation behaviour of
* its own, so a label click focuses nothing and toggles nothing. Both halves are this controller's
* job, for every form-associated control at once rather than once per component.
*
* The name is written straight onto the resolved target rather than routed through the component's
* template, for two reasons: no control has to grow an `externalLabel` property and a template
* binding for it, and the un-labelled value stays exactly what the component itself renders, so
* removing the label restores it *synchronously* — a template round-trip would leave the stale name
* in the accessibility tree until Lit's next update. Every write is snapshotted and reverted, and a
* revert whose value no longer matches what was applied is abandoned rather than forced, so a
* render that legitimately replaced the name (a host `aria-label` appearing) always wins.
*
* Host `aria-label` precedence is absolute: while the host carries one, the bridge applies nothing
* and lets the component's own forwarding put the host's name on the target.
*/
export declare class ExternalLabelController implements ReactiveController{private readonly host;private labels;private associationRootSubscription?;
/** The element currently carrying an applied name, and what it read before. */
private applied?;
/** Guards the synthetic activation click against an implicit (ancestor) label re-entering. */
private activating;constructor(host:ExternalLabelHost&ReactiveControllerHost);hostConnected():void;hostUpdated():void;hostDisconnected():void;
/** Re-resolves the associated labels, re-arms observation, and re-applies the name. */
private refresh;
/** Whether label activation is currently barred — the control's own `disabled` or an ancestor
*  `<fieldset disabled>`. `:disabled` is the authority (it is the only selector that tracks
*  fieldset cascading), with the component's own flags consulted for a DOM that does not match
*  a form-associated custom element against it. */
private get barred();
/** The element that owns the control's role — where the external name belongs. */
private resolveNameTarget;
/** The outermost ancestor of `node` that this control renders itself or hosts as a slotted
*  child, walking the composed tree up to (but never including) the host. */
private outermostOwnedAncestor;private get ownRoot();private resolveFocusTarget;
/** Host-owned semantic controls opt in with a symbol so the protocol cannot accidentally become
* a reflected/public component member. */
private get hostSemanticOwner();private hostHasAuthoredName;
/** How a label click reaches this control. */
private resolveActivation;
/** Applies (or withdraws) the external name on the current role owner. */
private apply;
/**
* Puts the target's own name back.
*
* Only when the attribute still reads what was applied: a component that re-rendered a *different*
* name in the meantime (the host gained an `aria-label`) has stated the newer truth, and restoring
* the stale snapshot over it would be the bridge overruling the control it is helping.
*/
private release;private readonly onLabelClick;}export{};