import type { ComponentPropsWithRef, ReactElement, ReactNode, Ref } from "react";
import type { SlotProps } from "../slotProps.ts";
/**
 * Everything else a caller writes on a `Field` reaches **the control
 * it clones onto**, not the `<div>` around it.
 *
 * That is not a new destination, it is the existing one finally
 * declared. `SlotProps` was a *closed* five-key type over a runtime
 * that already spread `...receivedSlotProps` into the clone, so
 * `name`, `placeholder`, `autoFocus`, `onBlur` and every `aria-*` all
 * arrived at the `<input>` and none of them type-checked. The only
 * prop a consumer could legally pass was `className` — which is the
 * one escape hatch the fleet's "configured by props, not a borrowed
 * class" rule is trying to close, so the closed type forced the very
 * thing the rule forbids
 * ([decision](../../../../docs/decisions/2026-08-21-a-slot-components-rest-props-are-the-controls-props.md)).
 *
 * `className` stays on the `<div>`, alone, because a class is a
 * statement about the box a **parent** lays out
 * ([decision](../../../../docs/decisions/2026-08-19-classname-is-the-outermost-box-a-component-renders.md)).
 * Every other prop is a statement about the control, and `id` is the
 * proof: it has named the control since the component shipped, and a
 * dated record settles its precedence
 * ([decision](../../../../docs/decisions/2026-08-05-field-adopts-the-childs-own-id.md)).
 * Routing the rest to the `<div>` would have moved it, silently, in
 * every consumer.
 *
 * `"input"` because `SlotProps` already picks from
 * `InputHTMLAttributes` and this is the same set widened, not a
 * second opinion about what a control is. `ref` is re-declared over
 * `HTMLElement`: the child may be a `Picker`'s `<button>` or a
 * `contenteditable` `<div>`, so `Ref<HTMLInputElement>` would be a
 * narrower claim than the slot makes.
 */
type ForwardedControlProps = Omit<ComponentPropsWithRef<"input">, "children" | "className" | "ref">;
export type FieldProps = ForwardedControlProps & SlotProps & {
    /**
     * The control. **Cloned, not wrapped** — the same slot contract
     * as `Popover`'s trigger, so a `Field` can go around an `<input>`,
     * a `<textarea>`, a `Picker`, or an app's own control without
     * changing that control's layout.
     */
    children: ReactElement;
    /**
     * The `<div>` around the label, the control and the messages —
     * the one prop that does **not** reach the control.
     */
    className?: string;
    /**
     * Standing help — units, a format, a warning about what the value
     * does. Announced with the control, before any error.
     */
    description?: ReactNode;
    /**
     * Present means invalid. There is no separate `isInvalid`, because
     * two sources for one fact is how a control ends up
     * `aria-invalid="true"` with nothing saying why — which is what
     * `RegexWithFlagsField` does in mux-magic today.
     */
    error?: ReactNode;
    isRequired?: boolean;
    label: ReactNode;
    /**
     * Merged onto the control's own, never replacing it — the wiring
     * rule `mergeSlotWiring` states for every slot.
     */
    ref?: Ref<HTMLElement>;
};
/**
 * Sixteen files in the fleet spell a label, a control, and a hint,
 * and no two spell the wiring the same way.
 *
 * ### What mux-magic's `FieldLabel` actually gets wrong
 *
 * An earlier version of this docstring said it "renders a `<label>`
 * with no `htmlFor` at all". **That is false** — it renders
 * ``htmlFor={`${stepId}-${field.name}`}``, and has since it was
 * written. The defect is at the other end of the pair: **8 of its 16
 * call sites never render that id on anything**. Measured on
 * `mux-magic@master`, the eight that do are `BooleanField`,
 * `ChapterSplitsField`, `EnumField`, `NumberField`,
 * `NumberWithLookupField`, `PathField`, `StringArrayField` and
 * `StringField`; the other eight either render no id at all or render
 * a different one — `RegexWithFlagsField` mints its own `patternId` /
 * `flagsId` / `sampleId`, and `SubtitleRulesField` spells
 * ``${step.command}-hasDefaultRules`` where the label says
 * ``${step.id}-…``.
 *
 * The outcome is the same unnamed textbox, by a worse route: a
 * `<label>` that points at an id nowhere in the document reads as
 * correct in the label's own file, and is only wrong in the *other*
 * file. Half of them are broken and nothing says which half.
 *
 * That is the argument for a component rather than a convention: here
 * the id is minted and consumed in one place and cannot be spelled
 * twice.
 *
 * ### The ids are static, and that is why `createLinkedIds` is not here
 *
 * The plan expected `useLinkedIds` to do this wiring. It does not
 * fit, for the same reason it did not fit `Tabs`: that kind exists
 * for a **dynamic** pairing, where the registration multiset is what
 * stops an `aria-describedby` naming a node React has already
 * removed. A field renders its own description and its own error, so
 * it knows at render which of them exist — the ids come from one
 * `useUniqueId` and a conditional join, and they cannot get out of
 * step at all.
 *
 * That leaves `createLinkedIds` with **no consumer in this package
 * across twenty-five components**, which is worth saying plainly
 * rather than manufacturing a use for. It is the one state kind the
 * component layer has never needed.
 *
 * ### Order matters inside `aria-describedby`
 *
 * Description first, error second. A screen reader reads the list in
 * order, and "millisecondsonly — required" is a different sentence
 * from "required — milliseconds only". Nothing enforces this but the
 * order of the array below, which is why it is not built from an
 * object.
 *
 * ### The error is described, not announced
 *
 * No `role="alert"` and no live region here, deliberately. An error
 * bound through `aria-describedby` is read when the control takes
 * focus, which is when the user can act on it; a live region on the
 * same text announces it a second time, from nowhere, while the
 * caret is elsewhere. A form that fails on submit should say so
 * once, at the top, with the `Alert` this library already ships —
 * and then the user tabs into the field and hears the specific
 * reason.
 *
 * ### A slot is a pass-through
 *
 * A `Tooltip` between the field and its control is the obvious thing
 * to write, and it is what mux-magic's `FieldLabel` does. Both
 * components clone onto their one child, so everything below used to
 * land on the `Tooltip` **component** and be dropped in silence —
 * leaving the `<label htmlFor>` above pointing at nothing, which is
 * precisely the defect this component was built to make impossible.
 * `SlotProps` arriving from an outer slot is forwarded down, and
 * `aria-describedby` is merged rather than replaced.
 * `slotProps.ts` has the reasoning.
 *
 * ### …and a pass-through cannot tell who wrote the prop
 *
 * Which is why the rest props are the **control's** props and not the
 * `<div>`'s. `receivedSlotProps` below is one object holding two
 * things that are indistinguishable at runtime: what a cloning
 * ancestor injected, and what the author typed on the `Field` itself.
 * A `Tooltip` above hands down `getReferenceProps()` — hover, focus
 * and dismiss handlers, `refs.setReference`, and an
 * `aria-describedby` naming the tip — and every bit of it has to
 * reach the `<input>` at the bottom. Sending the rest to the wrapper
 * would need a closed runtime allow-list to hold that case back, and
 * an allow-list is `FieldTooltip`'s silent drop rebuilt inside the
 * fix for it: the first slot that writes an `aria-expanded` is broken
 * and nothing says so.
 *
 * So there is one rule, and it has no exceptions to remember:
 * `className` is the box, everything else is the control. A caller
 * that needs a handle on the **box** — an `id` for a screenshot, a
 * `hidden` that takes the label with it — wants `FieldGroup`, which
 * wraps rather than clones and whose rest props land on its own
 * `<fieldset>`.
 */
export declare const Field: ({ children, className, description, error, isRequired, label, ...receivedSlotProps }: FieldProps) => ReactNode;
export {};
//# sourceMappingURL=Field.d.ts.map