import type { JSX } from "@solidjs/web";
import { type Accessor } from "solid-js";
import { type FieldRootState, type FieldValidationMode, type FieldValidityData } from "./field-constants.js";
export type { FieldRootState, FieldValidationMode, FieldValidityData, FieldValidityState, } from "./field-constants.js";
export { createDefaultValidityData, DEFAULT_FIELD_ROOT_STATE, DEFAULT_FIELD_STATE_ATTRIBUTES, DEFAULT_VALIDITY_STATE, getCombinedFieldValidityData, } from "./field-constants.js";
/**
 * Validate function signature exposed by `<Field.Root validate>`. Mirrors
 * React: the consumer receives the current value plus a snapshot of every
 * sibling field's value (keyed by field name) and returns a string / list
 * of strings / `null` synchronously, or a Promise resolving to the same.
 */
export type FieldValidateFn = (value: unknown, formValues: Record<string, unknown>) => string | string[] | null | Promise<string | string[] | null>;
/**
 * Registration payload a control pushes into `<Field.Root>`. Mirrors React's
 * `FieldControlRegistration`.
 */
export interface FieldRegistration {
    /**
     * Control DOM ref. The `<Field.Root>` uses this for imperative work on
     * submit (focus, scroll-into-view, etc). Plain ref object — identity is
     * stable across the control's lifetime.
     */
    controlRef: {
        current: HTMLElement | null;
    };
    /** Explicit getter, if the control needs to derive its current value. */
    getValue?: (() => unknown) | undefined;
    /** Identifier the parent `<Form>` uses to key this field in its map. */
    id: string | undefined;
    /** Last-known value (used when `getValue` is absent). */
    value: unknown;
}
/**
 * Mutable-by-design ref the field root uses to track whether the user has
 * interacted with the control (typed, cleared, etc). Exposed so validation
 * code can suppress "required" errors until the user has actually touched
 * the field — see `useFieldValidation.getState()`. Plain mutable object; do
 * NOT put a signal in here.
 */
export interface MutableRef<T> {
    current: T;
}
/**
 * Props-factory return shape produced by `useFieldValidation`. Consumers
 * splat these onto their element (the root element + the native input).
 *
 * Kept as a plain object-builder rather than a reactive memo because Solid
 * already tracks the individual accessors the builders read from.
 */
export interface FieldValidationProps {
    /**
     * Adds a11y hooks (`aria-describedby` from description, `aria-invalid`
     * once validity is known). Call inside a `get prop()` getter or reactive
     * scope if the consumer wants live updates.
     */
    getValidationProps: (externalProps?: JSX.HTMLAttributes<HTMLElement>) => JSX.HTMLAttributes<HTMLElement>;
    /**
     * Same as {@link FieldValidationProps.getValidationProps}, plus an
     * `onInput`-equivalent that commits the value to the validity pipeline.
     */
    getInputValidationProps: (externalProps?: JSX.InputHTMLAttributes<HTMLInputElement>) => JSX.InputHTMLAttributes<HTMLInputElement>;
    /** Native input ref captured by the validation pipeline. */
    inputRef: MutableRef<HTMLInputElement | null>;
    /**
     * Imperatively run validation against `value`. `revalidate` short-circuits
     * to "only revalidate if currently invalid" — see React's
     * `useFieldValidation.commit` for the full matrix.
     */
    commit: (value: unknown, revalidate?: boolean) => Promise<void>;
}
/**
 * The value handed down by `<Field.Root>` to its children.
 *
 * Every reactive entry is an `Accessor<T>` so that consumers pull the latest
 * value on demand and don't need to worry about top-level reactive reads.
 * Setters are plain functions (most of them wrapped through
 * `createStableCallback` so they're safe to capture in refs/closures).
 *
 * When `<Field.Root>` is absent, consumers receive {@link NOOP_FIELD_CONTEXT}
 * which behaves like "no field" — accessors return defaults, setters do
 * nothing.
 */
export interface FieldContextValue {
    invalid: Accessor<boolean>;
    name: Accessor<string | undefined>;
    disabled: Accessor<boolean>;
    validityData: Accessor<FieldValidityData>;
    setValidityData: (next: FieldValidityData) => void;
    touched: Accessor<boolean>;
    setTouched: (next: boolean) => void;
    dirty: Accessor<boolean>;
    setDirty: (next: boolean) => void;
    filled: Accessor<boolean>;
    setFilled: (next: boolean) => void;
    focused: Accessor<boolean>;
    setFocused: (next: boolean) => void;
    state: Accessor<FieldRootState>;
    validate: Accessor<FieldValidateFn | undefined>;
    validationMode: Accessor<FieldValidationMode>;
    validationDebounceTime: Accessor<number>;
    shouldValidateOnChange: Accessor<boolean>;
    /**
     * Mutable latch flipped to `true` the first time the user meaningfully
     * touches the field. Consumed by `useFieldValidation` to gate
     * "valueMissing"-only errors.
     */
    markedDirtyRef: MutableRef<boolean>;
    /**
     * Register (or unregister, via `registration === undefined`) a control.
     * The `source` symbol is created once per control setup and used to
     * detect stale unregistrations.
     */
    registerFieldControl: (source: symbol, registration: FieldRegistration | undefined) => void;
    /** Props-factories + `inputRef` + `commit` from the validation pipeline. */
    validation: FieldValidationProps;
    /** Marker — `true` when this context was provided by a real `<Field.Root>`. */
    readonly present: boolean;
}
export declare const NOOP_FIELD_CONTEXT: FieldContextValue;
/**
 * Context carrying the field-root state. Use `<FieldContext value={...}>` to
 * provide it (Solid 2's context-as-provider pattern).
 */
export declare const FieldContext: import("solid-js").Context<FieldContextValue>;
/**
 * Read the current `<Field.Root>` context. Returns the noop context when the
 * component is not wrapped in a field — callers can branch on `.present`.
 *
 * Named after React's `useFieldRootContext`.
 */
export declare function useFieldRootContext(): FieldContextValue;
//# sourceMappingURL=field-context.d.ts.map