import { type Accessor } from "solid-js";
/**
 * The value handed down by `<LabelableProvider>` to its descendants.
 *
 * Solid 2 adaptations from Base UI React's `LabelableContext`:
 *
 * - All reactive values are exposed as `Accessor<T>` so callers pull on demand
 *   and don't trip the top-level reactive read rule (RFC 01).
 * - The single `labelId` from React is generalized to a registry keyed by a
 *   per-consumer source `symbol`. Multiple labels can register into the same
 *   provider — `getLabelIds()` returns them in registration order, which
 *   `useAriaLabelledBy` joins with spaces. This is the multi-label superset of
 *   `use-registered-label-id.ts` (which progress/meter still use for their
 *   simpler single-id case).
 * - Setters are plain functions that may be called from owned scope on setup
 *   or from cleanup. The underlying signals opt into `ownedWrite` where
 *   appropriate so those writes don't trip `SIGNAL_WRITE_IN_OWNED_SCOPE`.
 * - `controlId` follows React's semantics: explicit `null` means "no
 *   association" (implicit label), `undefined` means "no registration yet",
 *   any string is the resolved control id.
 */
export interface LabelableContextValue {
    /**
     * The `id` of the labelable (control) element.
     * `null` when the association is implicit (control wrapped by a native
     * `<label>`); `undefined` when nothing has registered yet.
     */
    controlId: Accessor<string | null | undefined>;
    /**
     * Register a control id from a labelable control. Pass `undefined` to
     * unregister. Multiple calls with the same `source` replace the previous
     * registration for that source.
     */
    registerControlId: (source: symbol, id: string | null | undefined) => void;
    /**
     * Register a label id from a label component. Pass `undefined` to
     * unregister. Labels are returned by {@link getLabelIds} in the order they
     * registered.
     */
    registerLabelId: (source: symbol, id: string | undefined) => void;
    /**
     * Snapshot of currently registered label ids in registration order. Reading
     * this accessor subscribes to label registrations — when a label mounts or
     * unmounts, the consuming memo/effect re-runs.
     */
    getLabelIds: Accessor<readonly string[]>;
    /** Marker — `true` when this context was provided by a real `<LabelableProvider>`. */
    readonly present: boolean;
}
/**
 * The noop context used when no `<LabelableProvider>` is an ancestor. All
 * accessors return "nothing" and setters are no-ops, so consumers don't need
 * to branch on presence for correctness — they can just call through.
 */
export declare const NOOP_LABELABLE_CONTEXT: LabelableContextValue;
/**
 * Context for [labelable elements](https://html.spec.whatwg.org/multipage/forms.html#category-label)
 * — provides a two-way channel between label components and the control they
 * label, so each side can discover the other's id without the consumer having
 * to thread them manually.
 *
 * Provide with `<LabelableContext value={...}>` (Solid 2 context-as-provider
 * pattern — RFC 02). In practice, use `<LabelableProvider>` which constructs
 * the context internally.
 */
export declare const LabelableContext: import("solid-js").Context<LabelableContextValue>;
/**
 * Read the nearest `<LabelableProvider>` context. Returns the noop context
 * when no provider is an ancestor; callers can branch on `.present` if they
 * need to detect that case, or just call through (setters are no-ops, the
 * id accessor returns `undefined`).
 */
export declare function useLabelableContext(): LabelableContextValue;
//# sourceMappingURL=labelable-context.d.ts.map