/**
 * The references a widget's parts must make to each other.
 *
 * Dimension 3 of the specification. These relations existed in two places and neither was the
 * contract: the projections emit them at runtime, and the conformance inspector re-stated the rules
 * in its own code. A rule that lives only in the checker cannot be read by someone implementing the
 * widget, which is precisely what this contract is supposed to make possible.
 *
 * Declaring them also changes what can be caught. The inspector could only ever find a reference
 * that pointed at nothing — a *dangling* id. A control carrying no reference at all has nothing to
 * dangle, so a field whose errors reach no assistive technology looked identical to one with no
 * errors.
 */
import { type MdyWidgetKind } from "./catalog.js";
/** The attributes that carry a reference from one part to another. */
export type MdyRelationAttribute = "for" | "aria-describedby" | "aria-labelledby" | "aria-controls" | "aria-activedescendant";
export interface MdyWidgetRelation {
    /** The part carrying the attribute. */
    readonly from: string;
    readonly attribute: MdyRelationAttribute;
    /**
     * The parts it may name, in order of preference. The first one *rendered* is the one it must
     * name — `aria-describedby` points at the error list while there is one and at the supporting
     * text otherwise, and both are the same relation rather than two.
     */
    readonly to: readonly string[];
}
/** Every relation each kind's parts must make, derived from one declaration per relation type. */
export declare const MDY_WIDGET_RELATIONS: Readonly<Record<MdyWidgetKind, readonly MdyWidgetRelation[]>>;
/**
 * Elements a `for` may legitimately name.
 *
 * The HTML rule, not a preference: `label[for]` resolves only to a labelable element, so naming
 * anything else is markup a browser ignores.
 */
export declare const MDY_LABELABLE_TAGS: readonly string[];
/**
 * How a part comes by its accessible name.
 *
 * Dimension 2's remaining half. `element` says what a part *is* and the relations say what it points
 * at; this says how a screen reader is supposed to announce it.
 */
export type MdyAccessibleNameSource = 
/** The host language does it: a `<label for>`, or a label wrapping the control. */
"native"
/** `aria-labelledby`, naming a part that carries the text. */
 | "labelledby"
/** `aria-label`, because there is no visible text to point at. An icon-only button, a palette. */
 | "label";
/**
 * Semantics that must carry a name whatever kind they appear on.
 *
 * A rule rather than a table per kind, because the requirement comes from what the element *is*: a
 * listbox, a grid or a dialog with no name is announced as an unlabelled container, and the user has
 * to guess what they have landed in. Which mechanism supplies it is the renderer's to choose — the
 * text is the renderer's to translate — but that it has one is not optional.
 */
export declare const MDY_SEMANTICS_REQUIRING_NAME: readonly string[];
/** The parts of a kind that must be announced with a name of their own. */
export declare function partsRequiringName(kind: MdyWidgetKind): readonly string[];
/**
 * Opens the platform's own colour chooser from the hidden native input.
 *
 * `showPicker` and not a click: a renderer may guard that input's click to keep a press on the
 * swatch from reaching it twice, and a guarded click is one this door cannot open — the button says
 * it opens something and does nothing, which is the defect a door exists to avoid. The click is the
 * fallback for a platform without the explicit call.
 *
 * Called rather than focused. On some platforms the chooser is a separate window; a panel that
 * dismissed when focus left the page would take the door with it and leave nothing to come back to.
 */
export declare function openPlatformChooser(control: HTMLInputElement | null | undefined): void;