@privaty/ui-forms 0.1.0

package/dist/inputs/text-input.svelte

@@ -0,0 +1,126 @@
+<!-- @component
+Text-family input (text, email, password, search, url, tel) wired to a
+SvelteKit remote form string field — must render inside a <Form>, whose
+context it registers with. Shows resolver-translated validation errors once
+the form state reveals them, plus a majority-aware required/optional marker,
+and turns readonly while the form submits.
+-->
+<script lang="ts">
+  import { cn } from "@privaty/ui/cn.js";
+  import Input from "@privaty/ui/components/input.svelte";
+  import type { LabelStyle } from "@privaty/ui/components/types.js";
+  import type { HTMLInputAttributes } from "svelte/elements";
+  import type { TextField, TextFieldType } from "../types/field";
+  import { wireField } from "./wire-field";
+
+  interface Props {
+    /** The SvelteKit remote form field to bind. Structural — anything
+     * satisfying the TextField slice works, e.g. a fake from the public
+     * testing subpath. */
+    field: TextField;
+    /** Visible label text. In the floating label style it doubles as the
+     * placeholder. */
+    label: string;
+    /** Native input type within the text family. Defaults to "text". */
+    type?: TextFieldType;
+
+    /** Label placement: "top" (default), "left", "floating", or "hidden"
+     * (visually hidden, still read by screen readers). */
+    labelStyle?: LabelStyle;
+
+    /** Marks the field required: feeds the majority-aware required/optional
+     * marker (required markers styled red) — forms where at least half the
+     * fields are required mark the optional ones instead. Validation itself
+     * comes from the field's schema, not this flag, and it is not forwarded
+     * as a native `required` attribute. */
+    required?: boolean;
+    /** Disables the control. Disabled controls are excluded from FormData —
+     * never disable to lock the form during submit; the input already turns
+     * readonly while submitting. */
+    disabled?: boolean;
+    /** Renders the input readonly. Also forced on while the form is
+     * submitting, independent of this prop. */
+    readonly?: boolean;
+
+    /** Seed handed to Kit's `as()` (defaults to "") — the value native form
+     * reset restores and the baseline for dirty tracking. Assumed stable for
+     * the component's lifetime. */
+    initialValue?: string;
+
+    /** Placeholder text — ignored in the floating label style, where the
+     * label plays that role. */
+    placeholder?: string;
+    /** Forwarded to the native input. */
+    autocomplete?: HTMLInputAttributes["autocomplete"];
+
+    /** Extra classes for the outer field wrapper. */
+    class?: string;
+    /** Extra classes for the <label> element. */
+    labelClass?: string;
+    /** Extra classes for the <input> element. */
+    inputClass?: string;
+    /** Extra classes for the required/optional marker. */
+    markerClass?: string;
+    /** Extra classes for the error <ul>. */
+    errorClass?: string;
+  }
+
+  const {
+    field,
+    label,
+    type = "text",
+
+    labelStyle,
+
+    required = false,
+    disabled = false,
+    readonly = false,
+
+    initialValue = "",
+
+    placeholder,
+    autocomplete,
+
+    class: classes,
+    labelClass,
+    inputClass,
+    markerClass,
+    errorClass,
+  }: Props = $props();
+
+  const attributes = $derived(field.as(type, initialValue));
+
+  // The field, type, and initialValue are stable for the component's lifetime,
+  // so capturing the initial name and registration is intentional.
+  // svelte-ignore state_referenced_locally
+  const name = attributes.name;
+
+  // svelte-ignore state_referenced_locally
+  const wired = wireField({
+    name,
+    initialValue,
+    required,
+    issues: () => field.issues(),
+    getValue: () => field.value(),
+    setValue: (value) => field.set(value as string),
+    normalize: (value) => (value == null ? "" : String(value)),
+  });
+</script>
+
+<Input
+  {...attributes}
+  {label}
+  {labelStyle}
+  errors={wired.errors}
+  marker={wired.marker}
+  aria-invalid={wired.errors.length > 0 ? true : undefined}
+  {disabled}
+  readonly={readonly || wired.state.isSubmitting}
+  {placeholder}
+  {autocomplete}
+  class={classes}
+  {labelClass}
+  {inputClass}
+  markerClass={cn(required && "text-red-700 dark:text-red-500", markerClass)}
+  {errorClass}
+/>

package/dist/inputs/text-input.svelte.d.ts

@@ -0,0 +1,59 @@
+import type { LabelStyle } from "@privaty/ui/components/types.js";
+import type { HTMLInputAttributes } from "svelte/elements";
+import type { TextField, TextFieldType } from "../types/field";
+interface Props {
+    /** The SvelteKit remote form field to bind. Structural — anything
+     * satisfying the TextField slice works, e.g. a fake from the public
+     * testing subpath. */
+    field: TextField;
+    /** Visible label text. In the floating label style it doubles as the
+     * placeholder. */
+    label: string;
+    /** Native input type within the text family. Defaults to "text". */
+    type?: TextFieldType;
+    /** Label placement: "top" (default), "left", "floating", or "hidden"
+     * (visually hidden, still read by screen readers). */
+    labelStyle?: LabelStyle;
+    /** Marks the field required: feeds the majority-aware required/optional
+     * marker (required markers styled red) — forms where at least half the
+     * fields are required mark the optional ones instead. Validation itself
+     * comes from the field's schema, not this flag, and it is not forwarded
+     * as a native `required` attribute. */
+    required?: boolean;
+    /** Disables the control. Disabled controls are excluded from FormData —
+     * never disable to lock the form during submit; the input already turns
+     * readonly while submitting. */
+    disabled?: boolean;
+    /** Renders the input readonly. Also forced on while the form is
+     * submitting, independent of this prop. */
+    readonly?: boolean;
+    /** Seed handed to Kit's `as()` (defaults to "") — the value native form
+     * reset restores and the baseline for dirty tracking. Assumed stable for
+     * the component's lifetime. */
+    initialValue?: string;
+    /** Placeholder text — ignored in the floating label style, where the
+     * label plays that role. */
+    placeholder?: string;
+    /** Forwarded to the native input. */
+    autocomplete?: HTMLInputAttributes["autocomplete"];
+    /** Extra classes for the outer field wrapper. */
+    class?: string;
+    /** Extra classes for the <label> element. */
+    labelClass?: string;
+    /** Extra classes for the <input> element. */
+    inputClass?: string;
+    /** Extra classes for the required/optional marker. */
+    markerClass?: string;
+    /** Extra classes for the error <ul>. */
+    errorClass?: string;
+}
+/**
+ * Text-family input (text, email, password, search, url, tel) wired to a
+ * SvelteKit remote form string field — must render inside a <Form>, whose
+ * context it registers with. Shows resolver-translated validation errors once
+ * the form state reveals them, plus a majority-aware required/optional marker,
+ * and turns readonly while the form submits.
+ */
+declare const TextInput: import("svelte").Component<Props, {}, "">;
+type TextInput = ReturnType<typeof TextInput>;
+export default TextInput;

package/dist/inputs/textarea-input.svelte

@@ -0,0 +1,135 @@
+<!-- @component
+Multi-line text input wired to a SvelteKit remote form string field, rendered
+as a textarea — must render inside a <Form>, whose context it registers with.
+Shows resolver-translated validation errors once the form state reveals them,
+plus a majority-aware required/optional marker, and turns readonly while the
+form submits. No floating label style — that is tuned to single-line inputs.
+-->
+<script lang="ts">
+  import { cn } from "@privaty/ui/cn.js";
+  import Textarea from "@privaty/ui/components/textarea.svelte";
+  import type { LabelStyle } from "@privaty/ui/components/types.js";
+  import type { HTMLTextareaAttributes } from "svelte/elements";
+  import type { TextField } from "../types/field";
+  import { wireField } from "./wire-field";
+
+  interface Props {
+    /** The SvelteKit remote form field to bind. Structural — anything
+     * satisfying the TextField slice works, e.g. a fake from the public
+     * testing subpath. */
+    field: TextField;
+    /** Visible label text for the control. */
+    label: string;
+
+    /** Label placement: "top" (default), "left", or "hidden" (visually
+     * hidden, still read by screen readers). */
+    labelStyle?: Exclude<LabelStyle, "floating">;
+
+    /** Marks the field required: feeds the majority-aware required/optional
+     * marker (required markers styled red) — forms where at least half the
+     * fields are required mark the optional ones instead. Validation itself
+     * comes from the field's schema, not this flag, and it is not forwarded
+     * as a native `required` attribute. */
+    required?: boolean;
+    /** Disables the control. Disabled controls are excluded from FormData —
+     * never disable to lock the form during submit; the textarea already
+     * turns readonly while submitting. */
+    disabled?: boolean;
+    /** Renders the textarea readonly. Also forced on while the form is
+     * submitting, independent of this prop. */
+    readonly?: boolean;
+
+    /** Seed handed to Kit's `as()` (defaults to "") — the value native form
+     * reset restores and the baseline for dirty tracking. Assumed stable for
+     * the component's lifetime. */
+    initialValue?: string;
+
+    /** Forwarded to the native textarea. */
+    placeholder?: string;
+    /** Forwarded to the native textarea. */
+    autocomplete?: HTMLTextareaAttributes["autocomplete"];
+    /** Visible line count (native `rows`). Defaults to 3. */
+    rows?: number;
+
+    /** Extra classes for the outer field wrapper. */
+    class?: string;
+    /** Extra classes for the <label> element. */
+    labelClass?: string;
+    /** Extra classes for the <textarea> element. */
+    textareaClass?: string;
+    /** Extra classes for the required/optional marker. */
+    markerClass?: string;
+    /** Extra classes for the error <ul>. */
+    errorClass?: string;
+  }
+
+  const {
+    field,
+    label,
+
+    labelStyle,
+
+    required = false,
+    disabled = false,
+    readonly = false,
+
+    initialValue = "",
+
+    placeholder,
+    autocomplete,
+    rows = 3,
+
+    class: classes,
+    labelClass,
+    textareaClass,
+    markerClass,
+    errorClass,
+  }: Props = $props();
+
+  // Kit has no textarea `as()` type — but `as("text")` returns exactly what
+  // a textarea needs (name, aria-invalid, the value accessors) and its text
+  // branch carries no `type` attribute to clash with the element.
+  const attributes = $derived(field.as("text", initialValue));
+
+  // The slice TYPES the return broadly as input attributes, whose event-
+  // handler element types clash with a textarea — at runtime the object only
+  // holds the textarea-compatible members above, so the spread is cast.
+  const textareaAttributes = $derived(
+    attributes as unknown as Omit<HTMLTextareaAttributes, "class">,
+  );
+
+  // The field and initialValue are stable for the component's lifetime, so
+  // capturing the initial name and registration is intentional.
+  // svelte-ignore state_referenced_locally
+  const name = attributes.name;
+
+  // svelte-ignore state_referenced_locally
+  const wired = wireField({
+    name,
+    initialValue,
+    required,
+    issues: () => field.issues(),
+    getValue: () => field.value(),
+    setValue: (value) => field.set(value as string),
+    normalize: (value) => (value == null ? "" : String(value)),
+  });
+</script>
+
+<Textarea
+  {...textareaAttributes}
+  {label}
+  {labelStyle}
+  errors={wired.errors}
+  marker={wired.marker}
+  aria-invalid={wired.errors.length > 0 ? true : undefined}
+  {disabled}
+  readonly={readonly || wired.state.isSubmitting}
+  {placeholder}
+  {autocomplete}
+  {rows}
+  class={classes}
+  {labelClass}
+  {textareaClass}
+  markerClass={cn(required && "text-red-700 dark:text-red-500", markerClass)}
+  {errorClass}
+/>

package/dist/inputs/textarea-input.svelte.d.ts

@@ -0,0 +1,57 @@
+import type { LabelStyle } from "@privaty/ui/components/types.js";
+import type { HTMLTextareaAttributes } from "svelte/elements";
+import type { TextField } from "../types/field";
+interface Props {
+    /** The SvelteKit remote form field to bind. Structural — anything
+     * satisfying the TextField slice works, e.g. a fake from the public
+     * testing subpath. */
+    field: TextField;
+    /** Visible label text for the control. */
+    label: string;
+    /** Label placement: "top" (default), "left", or "hidden" (visually
+     * hidden, still read by screen readers). */
+    labelStyle?: Exclude<LabelStyle, "floating">;
+    /** Marks the field required: feeds the majority-aware required/optional
+     * marker (required markers styled red) — forms where at least half the
+     * fields are required mark the optional ones instead. Validation itself
+     * comes from the field's schema, not this flag, and it is not forwarded
+     * as a native `required` attribute. */
+    required?: boolean;
+    /** Disables the control. Disabled controls are excluded from FormData —
+     * never disable to lock the form during submit; the textarea already
+     * turns readonly while submitting. */
+    disabled?: boolean;
+    /** Renders the textarea readonly. Also forced on while the form is
+     * submitting, independent of this prop. */
+    readonly?: boolean;
+    /** Seed handed to Kit's `as()` (defaults to "") — the value native form
+     * reset restores and the baseline for dirty tracking. Assumed stable for
+     * the component's lifetime. */
+    initialValue?: string;
+    /** Forwarded to the native textarea. */
+    placeholder?: string;
+    /** Forwarded to the native textarea. */
+    autocomplete?: HTMLTextareaAttributes["autocomplete"];
+    /** Visible line count (native `rows`). Defaults to 3. */
+    rows?: number;
+    /** Extra classes for the outer field wrapper. */
+    class?: string;
+    /** Extra classes for the <label> element. */
+    labelClass?: string;
+    /** Extra classes for the <textarea> element. */
+    textareaClass?: string;
+    /** Extra classes for the required/optional marker. */
+    markerClass?: string;
+    /** Extra classes for the error <ul>. */
+    errorClass?: string;
+}
+/**
+ * Multi-line text input wired to a SvelteKit remote form string field, rendered
+ * as a textarea — must render inside a <Form>, whose context it registers with.
+ * Shows resolver-translated validation errors once the form state reveals them,
+ * plus a majority-aware required/optional marker, and turns readonly while the
+ * form submits. No floating label style — that is tuned to single-line inputs.
+ */
+declare const TextareaInput: import("svelte").Component<Props, {}, "">;
+type TextareaInput = ReturnType<typeof TextareaInput>;
+export default TextareaInput;

package/dist/inputs/wire-field.d.ts

@@ -0,0 +1,44 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { FormState } from "../form-state.svelte";
+interface WireFieldOptions {
+    /** The field's form name (from the attributes Kit's `as(...)` returned).
+     * Must be unique within the form. */
+    name: string;
+    /** The typed seed value — the baseline for dirty comparison and what
+     * reset restores. */
+    initialValue: unknown;
+    /** Whether the field is required — feeds the majority-aware marker. */
+    required: boolean;
+    /** Returns the field's current issues (the field's `issues()`). */
+    issues: () => readonly StandardSchemaV1.Issue[] | undefined;
+    /** Reads the field's current value — raw DOM strings can appear mid-edit. */
+    getValue: () => unknown;
+    /** Writes a value back to the field — used by the form-level reset. */
+    setValue: (value: unknown) => void;
+    /** Maps raw field values onto the initialValue's domain before dirty
+     * comparison (e.g. "5" vs 5, "on" vs true). */
+    normalize: (value: unknown) => unknown;
+}
+interface WiredField {
+    /** The owning form's FormState — inputs read e.g. isSubmitting from it. */
+    state: FormState;
+    /** Resolver-translated issue messages, or empty while the field's issues
+     * are gated (not yet touched and no submit attempted). Recomputed on
+     * access, so template reads stay reactive. */
+    readonly errors: string[];
+    /** The required/optional label text for the field's marker, or undefined —
+     * only the form's minority kind is marked, and nothing renders until every
+     * field has registered. */
+    readonly marker: string | undefined;
+}
+/**
+ * The wiring every form input shares: registers the field with the FormState
+ * (unregistering on destroy), and exposes the gated, resolver-translated
+ * errors plus the majority-aware required/optional marker.
+ *
+ * Must be called during component init (it uses context and onDestroy). The
+ * getters recompute on access, so reads from a template stay reactive.
+ */
+declare function wireField(options: WireFieldOptions): WiredField;
+export { wireField };
+export type { WiredField, WireFieldOptions };

package/dist/inputs/wire-field.js

@@ -0,0 +1,45 @@
+import { getUiConfig } from "@privaty/ui/config/context.js";
+import { onDestroy } from "svelte";
+import { getFormContext } from "../context";
+/**
+ * The wiring every form input shares: registers the field with the FormState
+ * (unregistering on destroy), and exposes the gated, resolver-translated
+ * errors plus the majority-aware required/optional marker.
+ *
+ * Must be called during component init (it uses context and onDestroy). The
+ * getters recompute on access, so reads from a template stay reactive.
+ */
+function wireField(options) {
+    const { state } = getFormContext();
+    const config = getUiConfig();
+    onDestroy(state.register({
+        name: options.name,
+        initialValue: options.initialValue,
+        required: options.required,
+        getValue: options.getValue,
+        setValue: options.setValue,
+        normalize: options.normalize,
+    }));
+    return {
+        state,
+        get errors() {
+            return state.shouldShowIssues(options.name)
+                ? (options.issues() ?? []).map((issue) => config.resolveMessage(issue))
+                : [];
+        },
+        get marker() {
+            // Markers wait until every field has registered — a partial majority
+            // would render the wrong marker first (visible as an SSR/load flash).
+            if (!state.settled)
+                return undefined;
+            return state.majorityRequired
+                ? options.required
+                    ? undefined
+                    : config.labels.form.optional
+                : options.required
+                    ? config.labels.form.required
+                    : undefined;
+        },
+    };
+}
+export { wireField };

package/dist/testing/fakes.svelte.d.ts

@@ -0,0 +1,205 @@
+import type { CheckboxField, DateField, NumberField, SelectField, TextField } from "../types/field";
+import type { ValidatableForm } from "../types/form";
+/**
+ * Test doubles for the structural form interfaces. For use in specs and
+ * consumers' own tests — never imported by library runtime code.
+ */
+/**
+ * The minimal issue shape the library reads back from a form — a Standard
+ * Schema issue narrowed to what tests need to construct.
+ */
+interface FakeIssue {
+    /** Human-readable validation message. */
+    message: string;
+    /** Path segments locating the field the issue belongs to (Standard Schema
+     * shape). Omit for form-level issues. */
+    path?: readonly (string | number)[];
+}
+/**
+ * Minimal `ValidatableForm` fake for FormState-level tests. `computeIssues`
+ * runs on every `validate()` call and its result becomes the issue set that
+ * `fields.allIssues()` exposes (default: always valid). State is reactive —
+ * effects re-run on `setIssues`/`setPending`.
+ */
+declare function fakeForm(computeIssues?: () => readonly FakeIssue[] | undefined): {
+    /** The fake form — pass it where a `ValidatableForm` is expected. */
+    form: ValidatableForm;
+    /** Arguments of every `validate()` call, in order. */
+    validateCalls: unknown[];
+    /** Replaces the issue set directly, bypassing `validate()`. */
+    setIssues: (next: readonly FakeIssue[] | undefined) => void;
+    /** Sets the form's `pending` submission count. */
+    setPending: (next: number) => void;
+};
+/**
+ * Structural `TextField` fake for TextInput/TextareaInput tests. `as()`
+ * returns plain spreadable attributes (no attachment); value and issues are
+ * reactive state. Pass `options.issues` to seed the field with issues.
+ */
+declare function fakeTextField(name: string, options?: {
+    issues?: readonly {
+        message: string;
+    }[];
+}): {
+    /** The fake field — pass it as the input component's `field` prop. */
+    field: TextField;
+    /** Simulates USER typing (string fields store the same value `set()`
+     * would — no raw/typed split here). */
+    edit: (next: string) => void;
+    /** Replaces the field's issue set. */
+    setIssues: (next: readonly {
+        message: string;
+    }[] | undefined) => void;
+};
+/**
+ * Structural `DateField` fake for DateInput tests. The whole date family
+ * (date, month, week, time, datetime-local) carries ISO-style string values,
+ * so one fake covers all five. Same shape and reactivity as `fakeTextField`.
+ */
+declare function fakeDateField(name: string, options?: {
+    issues?: readonly {
+        message: string;
+    }[];
+}): {
+    /** The fake field — pass it as the input component's `field` prop. */
+    field: DateField;
+    /** Simulates USER input — an ISO-style string, same as `set()` would
+     * store. */
+    edit: (next: string) => void;
+    /** Replaces the field's issue set. */
+    setIssues: (next: readonly {
+        message: string;
+    }[] | undefined) => void;
+};
+/**
+ * Structural `NumberField` fake for NumberInput tests. Mirrors Kit's mid-edit
+ * behavior: `edit()` stores the raw DOM string a user's typing would produce,
+ * while `set()` stores the typed number — the distinction is what makes
+ * dirty-tracking tests meaningful.
+ */
+declare function fakeNumberField(name: string, options?: {
+    issues?: readonly {
+        message: string;
+    }[];
+}): {
+    /** The fake field — pass it as the input component's `field` prop. */
+    field: NumberField;
+    /** Simulates USER typing: stores the raw DOM string, like Kit does. */
+    edit: (next: number | undefined) => void;
+    /** Replaces the field's issue set. */
+    setIssues: (next: readonly {
+        message: string;
+    }[] | undefined) => void;
+};
+/**
+ * Structural `SelectField` fake for SelectInput tests. Same shape and
+ * reactivity as `fakeTextField` — select values are plain strings on both
+ * the DOM and typed sides.
+ */
+declare function fakeSelectField(name: string, options?: {
+    issues?: readonly {
+        message: string;
+    }[];
+}): {
+    /** The fake field — pass it as the input component's `field` prop. */
+    field: SelectField;
+    /** Simulates the USER choosing an option: stores its string value. */
+    edit: (next: string) => void;
+    /** Replaces the field's issue set. */
+    setIssues: (next: readonly {
+        message: string;
+    }[] | undefined) => void;
+};
+/**
+ * Structural `CheckboxField` fake for CheckboxInput tests. Like Kit's
+ * `as("checkbox", seed)`, the returned attributes expose `checked` and
+ * `defaultChecked` getters (the latter is what makes native reset restore
+ * the seed). `edit()` stores the raw DOM value ("on"/null) while `set()`
+ * stores the typed boolean — mirroring Kit's mid-edit behavior.
+ */
+declare function fakeCheckboxField(name: string, options?: {
+    issues?: readonly {
+        message: string;
+    }[];
+}): {
+    /** The fake field — pass it as the input component's `field` prop. */
+    field: CheckboxField;
+    /** Simulates a USER toggle: raw DOM value, like Kit's input listener. */
+    edit: (next: boolean) => void;
+    /** Replaces the field's issue set. */
+    setIssues: (next: readonly {
+        message: string;
+    }[] | undefined) => void;
+};
+/** The options object Kit's `validate()` accepts, as the fakes model it. */
+interface FakeValidateOptions {
+    /** Kit's flag to also surface issues on fields not yet edited and blurred
+     * (ignored after first submission). The fake attaches no behavior to it —
+     * it is only recorded in `validateCalls` and forwarded to `onValidate`. */
+    all?: boolean;
+    /** True for client-schema-only validation with no server round-trip. In
+     * the fake it decides issue origin (preflight issues are client-flagged,
+     * full validations server-flagged) and the merge-vs-replace semantics of
+     * the resulting issue set. */
+    preflightOnly?: boolean;
+}
+/** Behavior knobs for `fakeRemoteForm`. */
+interface FakeRemoteFormOptions {
+    /** Issues the next validation resolves with (default: none — valid). */
+    onValidate?: (options: FakeValidateOptions | undefined) => readonly FakeIssue[] | undefined;
+    /** Submission outcome: return false for "rejected by validation", throw for
+     * a failed request (default: true — success). May return a promise. */
+    onSubmit?: () => boolean | Promise<boolean>;
+    /** Issues installed — server-flagged, replacing the whole set — when
+     * onSubmit rejects, like Kit's rejected submissions do. Left unset, a
+     * rejection leaves the issue set untouched. */
+    serverIssues?: readonly FakeIssue[];
+    /** Hold every validate() unresolved until releaseValidate() is called. */
+    gateValidate?: boolean;
+    /** The value exposed as `form.result` after submission. */
+    result?: unknown;
+}
+/**
+ * A full-surface fake of a SvelteKit remote form for testing the Form
+ * component: `enhance` returns spreadable attributes whose attachment
+ * intercepts native submits (like Kit's does), so tests drive real buttons.
+ */
+declare function fakeRemoteForm(options?: FakeRemoteFormOptions): {
+    /** The fake remote form — pass it as the Form component's form. */
+    form: {
+        method: "POST";
+        action: string;
+        preflight: (schema: unknown) => /*elided*/ any;
+        enhance: (callback: (instance: ReturnType<(node: HTMLFormElement) => {
+            element: HTMLFormElement;
+            submit: () => Promise<boolean>;
+        }>) => unknown) => {
+            [x: symbol]: (node: HTMLFormElement) => () => void;
+            method: "POST";
+            action: string;
+        };
+        validate: (validateOptions?: FakeValidateOptions) => Promise<void>;
+        readonly result: unknown;
+        readonly pending: number;
+        fields: {
+            allIssues: () => {
+                message: string;
+                path: readonly (string | number)[] | undefined;
+            }[] | undefined;
+        };
+    };
+    /** Arguments of every `validate()` call, in order. */
+    validateCalls: (FakeValidateOptions | undefined)[];
+    /** Schemas passed to `preflight()`, in order. */
+    preflightCalls: unknown[];
+    /** Number of enhance submissions started so far. */
+    submitCount: () => number;
+    /** Resolves the oldest still-gated `validate()` — pairs with the
+     * `gateValidate` option. */
+    releaseValidate: () => void | undefined;
+    /** Installs server-flagged issues directly — models the SSR-restored
+     * issue set of a rejected no-JS submission. */
+    setServerIssues: (next: readonly FakeIssue[]) => void;
+};
+export { fakeCheckboxField, fakeDateField, fakeForm, fakeNumberField, fakeRemoteForm, fakeSelectField, fakeTextField, };
+export type { FakeIssue, FakeRemoteFormOptions, FakeValidateOptions };