import type{ReactiveController,ReactiveControllerHost}from'lit';
/**
* A declarative `match` constraint target: a sibling field's id (looked up in the host's own root
* node — an idref never crosses a shadow boundary, mirroring every other idref this library
* resolves, `internal/aria-controls.ts` included) or a direct element reference (works across
* shadow trees, since resolving one requires no lookup at all).
*/
export type LyraMatchTarget=string|HTMLElement|null;
/**
* Resolves a `match` target to a live element. Never throws: a dangling id, a root with no
* `getElementById` (an exotic root), or any other unresolved reference all answer `null`, so a
* `match` constraint that cannot be resolved is silently inert rather than permanently blocking
* submission.
*/
export declare function resolveMatchConstraintTarget(host:Element,match:LyraMatchTarget):HTMLElement|null;
/**
* Reads the comparable string value off a resolved match target — any element exposing a plain
* string `.value` (a native `<input>`/`<textarea>`, or a lyra form control). `null` when the
* target has none, so a constraint pointed at a value-less element never runs.
*/
export declare function readMatchConstraintValue(target:HTMLElement|null):string|null;
/**
* Keeps a `match` constraint's referenced field resolved and re-runs the host's own validity
* whenever that referenced field's value changes — so a confirm-password-shaped pair revalidates
* as the user edits either field, not only the one carrying the constraint.
*
* Rebinds its `input`/`change` listeners whenever the resolved target changes (a different id, an
* element reference swapped out, or the reference newly resolving/ceasing to resolve), checked on
* every host connect and after every host update — cheap, since resolution is one
* `getElementById()` call.
*/
export declare class MatchConstraintController implements ReactiveController{private readonly host;private readonly getMatch;private readonly onTargetValueChange;private target;constructor(host:ReactiveControllerHost&Element,getMatch:()=>LyraMatchTarget,onTargetValueChange:()=>void);private readonly handleTargetChange;hostConnected():void;hostUpdated():void;hostDisconnected():void;private sync;private unbind;
/** Whether `match` currently resolves to a live element — `false` for an unset constraint or a
*  dangling reference, so a caller can tell "no constraint" apart from "constraint satisfied". */
get hasTarget():boolean;
/** The resolved target's current comparable value, or `null` when unresolved or non-comparable. */
get targetValue():string|null;}