@privaty/ui-forms 0.1.0

package/dist/form-state.svelte.d.ts

@@ -0,0 +1,89 @@
+import type { FieldRegistration } from "./types/field";
+import type { ValidatableForm } from "./types/form";
+/**
+ * Client-side display state for a form: dirty/touched tracking and
+ * error-display gating.
+ *
+ * Kit v3 ships field.dirty(), field.touched() and form `submitted`, but none
+ * substitute for this class (evaluated against the next.23 source):
+ * - Kit's dirty() is an edited-once FLAG that never clears when a value is
+ *   edited back; isDirty here compares values, so edit-then-revert returns
+ *   to pristine — which drives Submit's dirty-and-valid gate and Reset's
+ *   disabled-while-pristine.
+ * - Kit's touched() flips on BLUR (and on set()); ours flips on input after
+ *   validation, so issues appear while typing in the flash-safe order.
+ * - Kit's `submitted` only flips once a submission actually starts;
+ *   submitAttempted must open the error gates on gate-BLOCKED attempts too.
+ */
+declare class FormState {
+    private form;
+    private fields;
+    private touched;
+    /**
+     * True once a submit has been attempted — including attempts a validation
+     * gate blocked before any submission started. Opens issue display for every
+     * field. Cleared by reset().
+     */
+    submitAttempted: boolean;
+    /**
+     * The error the latest submission flow threw, or undefined. Cleared when
+     * the next submission flow starts and by reset().
+     */
+    submitError: unknown;
+    /**
+     * True when the form has a client-side (preflight) schema, so validation
+     * triggered from here can stay off the network. Set by the Form component.
+     */
+    clientOnlyValidation: boolean;
+    /**
+     * True once every field has registered (the Form flips it on mount).
+     * Majority-dependent display like the required/optional markers waits for
+     * it — a partial registration set would render the wrong marker first.
+     */
+    settled: boolean;
+    constructor(form: ValidatableForm);
+    /**
+     * True while any registered field's current value differs from its initial
+     * value (compared through the field's normalizer), so edit-then-revert
+     * returns to pristine.
+     */
+    readonly isDirty: boolean;
+    /** True when the form currently has no issues — client- or server-produced. */
+    readonly isValid: boolean;
+    /** True while a submission is in flight (the form's `pending` count > 0). */
+    readonly isSubmitting: boolean;
+    /**
+     * True when at least as many registered fields are required as optional.
+     * Drives the marker convention: only the minority kind gets a marker, so
+     * mostly-required forms mark the optional fields and vice versa.
+     */
+    readonly majorityRequired: boolean;
+    /**
+     * Registers a field for dirty tracking, markers and reset. Returns the
+     * unregister function — pass it to onDestroy. Field names must be unique
+     * within a form; a duplicate name throws.
+     */
+    register(field: FieldRegistration): () => void;
+    /**
+     * Marks a field touched so shouldShowIssues() starts returning true for it.
+     * The Form calls this AFTER a validation pass settles, so a newly-touched
+     * field never flashes issues stale from the previous pass.
+     */
+    markTouched(name: string): void;
+    /**
+     * Whether the named field's issues may be displayed: everything shows once
+     * a submit was attempted, before that only touched fields do.
+     */
+    shouldShowIssues(name: string): boolean;
+    /**
+     * Fire-and-forget full validation of the underlying form — preflight-only
+     * (off the network) when clientOnlyValidation is set.
+     */
+    validate(): void;
+    /**
+     * Restores every registered field to its initial value, clears touched and
+     * submit state, and revalidates so stale issues don't outlive the reset.
+     */
+    reset(): void;
+}
+export { FormState };

package/dist/form-state.svelte.js

@@ -0,0 +1,139 @@
+import { SvelteMap, SvelteSet } from "svelte/reactivity";
+/**
+ * Client-side display state for a form: dirty/touched tracking and
+ * error-display gating.
+ *
+ * Kit v3 ships field.dirty(), field.touched() and form `submitted`, but none
+ * substitute for this class (evaluated against the next.23 source):
+ * - Kit's dirty() is an edited-once FLAG that never clears when a value is
+ *   edited back; isDirty here compares values, so edit-then-revert returns
+ *   to pristine — which drives Submit's dirty-and-valid gate and Reset's
+ *   disabled-while-pristine.
+ * - Kit's touched() flips on BLUR (and on set()); ours flips on input after
+ *   validation, so issues appear while typing in the flash-safe order.
+ * - Kit's `submitted` only flips once a submission actually starts;
+ *   submitAttempted must open the error gates on gate-BLOCKED attempts too.
+ */
+class FormState {
+    form;
+    fields = new SvelteMap();
+    touched = new SvelteSet();
+    /**
+     * True once a submit has been attempted — including attempts a validation
+     * gate blocked before any submission started. Opens issue display for every
+     * field. Cleared by reset().
+     */
+    submitAttempted = $state(false);
+    /**
+     * The error the latest submission flow threw, or undefined. Cleared when
+     * the next submission flow starts and by reset().
+     */
+    submitError = $state();
+    /**
+     * True when the form has a client-side (preflight) schema, so validation
+     * triggered from here can stay off the network. Set by the Form component.
+     */
+    clientOnlyValidation = false;
+    /**
+     * True once every field has registered (the Form flips it on mount).
+     * Majority-dependent display like the required/optional markers waits for
+     * it — a partial registration set would render the wrong marker first.
+     */
+    settled = $state(false);
+    constructor(form) {
+        this.form = form;
+    }
+    /**
+     * True while any registered field's current value differs from its initial
+     * value (compared through the field's normalizer), so edit-then-revert
+     * returns to pristine.
+     */
+    isDirty = $derived.by(() => {
+        for (const field of this.fields.values()) {
+            // Both sides pass through the field's normalizer: Kit stores raw DOM
+            // strings mid-edit while registrations hold typed seeds, so "5" vs 5
+            // and "on" vs true must compare equal. Only undefined means
+            // "untouched" — null is a real value (Kit's unchecked checkbox).
+            const raw = field.getValue();
+            const value = field.normalize(raw === undefined ? field.initialValue : raw);
+            if (value !== field.normalize(field.initialValue))
+                return true;
+        }
+        return false;
+    });
+    /** True when the form currently has no issues — client- or server-produced. */
+    isValid = $derived.by(() => !this.form.fields.allIssues()?.length);
+    /** True while a submission is in flight (the form's `pending` count > 0). */
+    isSubmitting = $derived.by(() => this.form.pending > 0);
+    /**
+     * True when at least as many registered fields are required as optional.
+     * Drives the marker convention: only the minority kind gets a marker, so
+     * mostly-required forms mark the optional fields and vice versa.
+     */
+    majorityRequired = $derived.by(() => {
+        let required = 0;
+        let optional = 0;
+        for (const field of this.fields.values()) {
+            if (field.required)
+                required++;
+            else
+                optional++;
+        }
+        return required >= optional;
+    });
+    /**
+     * Registers a field for dirty tracking, markers and reset. Returns the
+     * unregister function — pass it to onDestroy. Field names must be unique
+     * within a form; a duplicate name throws.
+     */
+    register(field) {
+        if (this.fields.has(field.name))
+            throw new Error(`FormState: field '${field.name}' is already registered`);
+        this.fields.set(field.name, field);
+        return () => {
+            this.fields.delete(field.name);
+            this.touched.delete(field.name);
+        };
+    }
+    /**
+     * Marks a field touched so shouldShowIssues() starts returning true for it.
+     * The Form calls this AFTER a validation pass settles, so a newly-touched
+     * field never flashes issues stale from the previous pass.
+     */
+    markTouched(name) {
+        this.touched.add(name);
+    }
+    /**
+     * Whether the named field's issues may be displayed: everything shows once
+     * a submit was attempted, before that only touched fields do.
+     */
+    shouldShowIssues(name) {
+        return this.submitAttempted || this.touched.has(name);
+    }
+    /**
+     * Fire-and-forget full validation of the underlying form — preflight-only
+     * (off the network) when clientOnlyValidation is set.
+     */
+    validate() {
+        // Defensive catch: validation for a form that unmounted (or failed a
+        // network round-trip) mid-call has nowhere useful to surface from here.
+        void Promise.resolve(this.form.validate({
+            all: true,
+            preflightOnly: this.clientOnlyValidation,
+        })).catch(() => { });
+    }
+    /**
+     * Restores every registered field to its initial value, clears touched and
+     * submit state, and revalidates so stale issues don't outlive the reset.
+     */
+    reset() {
+        for (const field of this.fields.values()) {
+            field.setValue(field.initialValue);
+        }
+        this.touched.clear();
+        this.submitAttempted = false;
+        this.submitError = undefined;
+        this.validate();
+    }
+}
+export { FormState };

package/dist/form.svelte

@@ -0,0 +1,219 @@
+<!-- @component
+Wrapper around a SvelteKit remote form: enhances it and provides the context
+every `@privaty/ui-forms` input and button requires. With a `schema`, typing
+validates client-side (preflight); without one, validation is a debounced
+server round-trip. A field's issues stay hidden until it is touched or a
+submit is attempted; submission always validates server-side regardless.
+-->
+<script lang="ts" generics="Input extends RemoteFormInput, Output">
+  import { cn } from "@privaty/ui/cn.js";
+  import type { RemoteForm, RemoteFormInput } from "$app/server";
+  import type { StandardSchemaV1 } from "@standard-schema/spec";
+  import { onDestroy, onMount, type Snippet } from "svelte";
+  import { setFormContext } from "./context";
+  import { FormState } from "./form-state.svelte";
+
+  type Props = {
+    /** The SvelteKit remote form instance to enhance. Captured on first
+     * render — it must stay the same instance for the component's lifetime. */
+    form: Omit<RemoteForm<Input, Output>, "for">;
+    /** Standard Schema for client-side (preflight) validation while typing —
+     * without it, every validation pass is a server round-trip.
+     * Output deliberately unconstrained: transform schemas (Output ≠ Input)
+     * are Kit-legal and only the Input side matters for preflight. */
+    schema?: StandardSchemaV1<Input, unknown>;
+
+    /** Debounce (ms) for validation while typing wherever validation is a
+     * server round-trip: always on SCHEMA-LESS forms, and on schema'd forms
+     * while server-produced issues are being refreshed. Client-side-only
+     * validation stays immediate. Defaults to 400. */
+    validationDebounce?: number;
+
+    /** Reset the form after a successful submission, restoring every field's
+     * initial value. Defaults to true. */
+    resetOnSuccess?: boolean;
+
+    /** Called after a successful submission with the remote function's
+     * result (after the reset when `resetOnSuccess` is on). */
+    onsuccess?: (result: Output | undefined) => void | Promise<void>;
+    /** Called when the submission flow throws — the round-trip, the submit
+     * itself, or `onsuccess`. The same error is kept as FormState.submitError,
+     * which <FormError> renders as a general error message. */
+    onerror?: (error: unknown) => void | Promise<void>;
+
+    /** Extra classes for the <form> element. */
+    class?: string;
+
+    /** Form content — the inputs and buttons that read this form's context. */
+    children: Snippet;
+  };
+
+  const {
+    form,
+    schema,
+
+    validationDebounce = 400,
+
+    resetOnSuccess = true,
+
+    onsuccess,
+    onerror,
+
+    class: classes,
+
+    children,
+  }: Props = $props();
+
+  // The remote form instance is stable for the component's lifetime, so
+  // capturing the initial prop value is intentional. When a schema is given,
+  // the preflighted instance is used for everything so client-side
+  // (`preflightOnly`) validation actually has a schema to run.
+  // svelte-ignore state_referenced_locally
+  const instance = schema ? form.preflight(schema) : form;
+
+  const state = new FormState(instance);
+  // svelte-ignore state_referenced_locally
+  state.clientOnlyValidation = schema !== undefined;
+  setFormContext({ form: instance, state });
+
+  // Kit flags issues that came from the SERVER (a rejected submission, a
+  // server validation round-trip) and persists them through every client-side
+  // validation pass — no edit can refresh them, only another round-trip
+  // (merge_with_server_issues, verified against next.25). The flag itself is
+  // stripped from the public issues shape, so their presence is tracked here:
+  // set on rejection, cleared by a clean full validation, submission or
+  // reset. While set, input revalidation escalates to full validation so
+  // server-judged rules (a cross-field cap, a uniqueness check) stay live.
+  let serverIssuesPresent = false;
+
+  // A parent mounts after its children, so every field has registered by now.
+  onMount(() => {
+    state.settled = true;
+
+    // Issues present before any client-side validation could have run are
+    // server-produced — the SSR-restored rejection of a no-JS submission.
+    serverIssuesPresent = (instance.fields.allIssues()?.length ?? 0) > 0;
+  });
+
+  // With a schema, typing validates client-side only — the server isn't
+  // involved until submission (which validates server-side regardless).
+  function validate() {
+    return instance.validate({
+      all: true,
+      preflightOnly: schema !== undefined,
+    });
+  }
+
+  const attributes = instance.enhance(async (enhanceInstance) => {
+    state.submitError = undefined;
+
+    try {
+      // Schema-less only: validate BEFORE opening the error gates (issues
+      // must be fresh when submitAttempted makes them all visible) and gate
+      // the submit on the fresh result. Inside the try: the validation is a
+      // server round-trip whose failure must surface as submitError, not
+      // escalate to the nearest +error page. Schema'd forms skip this — Kit's
+      // preflight already gated client validity before this callback ran
+      // (handleSubmit opens their gates), and lingering SERVER issues must
+      // never block here: client-side validation cannot refresh them, so
+      // gating on isValid would deadlock resubmission on problems the user
+      // already fixed. The submission itself re-judges them authoritatively.
+      if (schema === undefined) {
+        await validate();
+        state.submitAttempted = true;
+        if (!state.isValid) return;
+      }
+
+      if (!(await enhanceInstance.submit())) {
+        serverIssuesPresent = true;
+        return;
+      }
+      serverIssuesPresent = false;
+
+      if (resetOnSuccess) enhanceInstance.element.reset();
+
+      await onsuccess?.(instance.result);
+    } catch (error) {
+      state.submitError = error;
+      await onerror?.(error);
+    }
+  });
+
+  // With a schema, Kit's preflight runs BEFORE the enhance callback and
+  // silently swallows invalid submits — the callback never gets to flip
+  // submitAttempted, so a rejected click would show nothing anywhere. This
+  // form-level listener fires regardless of Kit's gate, validates (fresh
+  // issues before the gates open — the flash rule), then opens them.
+  function handleSubmit() {
+    if (schema === undefined) return;
+
+    void Promise.resolve(validate())
+      .catch(() => {})
+      .finally(() => {
+        state.submitAttempted = true;
+      });
+  }
+
+  let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+  onDestroy(() => clearTimeout(debounceTimer));
+
+  async function handleInput(event: Event) {
+    const name =
+      event.target instanceof HTMLElement
+        ? event.target.getAttribute("name")
+        : null;
+
+    // Schema'd forms validate client-side and immediately — EXCEPT while
+    // server issues linger, which client-side validation can never refresh:
+    // those passes escalate to full validation (client schema first, then —
+    // only once it passes — the server round-trip that replaces the whole
+    // issue set), so a server-judged rule updates live as its inputs change.
+    if (schema !== undefined && !serverIssuesPresent) {
+      try {
+        // Same ordering rule: a newly-touched field must never flash issues
+        // that are stale from the previous validation pass.
+        await validate();
+      } catch {
+        // The form can unmount mid-validation — nothing left to show on.
+      } finally {
+        if (name) state.markTouched(name);
+      }
+      return;
+    }
+
+    // Every validation from here is a server round-trip, so typing is
+    // debounced. The touch waits for the validation, preserving the
+    // no-stale-issues ordering.
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      void Promise.resolve(
+        instance.validate({ all: true, preflightOnly: false }),
+      )
+        .then(() => {
+          // An empty result proves the server issues are gone — drop back to
+          // the immediate client-only cadence. Non-empty stays escalated: the
+          // set may still hold server issues (their flag isn't visible here).
+          serverIssuesPresent = (instance.fields.allIssues()?.length ?? 0) > 0;
+        })
+        .catch(() => {})
+        .finally(() => {
+          if (name) state.markTouched(name);
+        });
+    }, validationDebounce);
+  }
+</script>
+
+<form
+  {...attributes}
+  class={cn("flex flex-col gap-3", classes)}
+  oninput={handleInput}
+  onsubmit={handleSubmit}
+  onreset={() => {
+    // Kit's own reset handler clears the whole issue set, server issues
+    // included.
+    serverIssuesPresent = false;
+    state.reset();
+  }}
+>
+  {@render children()}
+</form>

package/dist/form.svelte.d.ts

@@ -0,0 +1,62 @@
+import type { RemoteForm, RemoteFormInput } from "$app/server";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { type Snippet } from "svelte";
+declare function $$render<Input extends RemoteFormInput, Output>(): {
+    props: {
+        /** The SvelteKit remote form instance to enhance. Captured on first
+         * render — it must stay the same instance for the component's lifetime. */
+        form: Omit<RemoteForm<Input, Output>, "for">;
+        /** Standard Schema for client-side (preflight) validation while typing —
+         * without it, every validation pass is a server round-trip.
+         * Output deliberately unconstrained: transform schemas (Output ≠ Input)
+         * are Kit-legal and only the Input side matters for preflight. */
+        schema?: StandardSchemaV1<Input, unknown>;
+        /** Debounce (ms) for validation while typing wherever validation is a
+         * server round-trip: always on SCHEMA-LESS forms, and on schema'd forms
+         * while server-produced issues are being refreshed. Client-side-only
+         * validation stays immediate. Defaults to 400. */
+        validationDebounce?: number;
+        /** Reset the form after a successful submission, restoring every field's
+         * initial value. Defaults to true. */
+        resetOnSuccess?: boolean;
+        /** Called after a successful submission with the remote function's
+         * result (after the reset when `resetOnSuccess` is on). */
+        onsuccess?: (result: Output | undefined) => void | Promise<void>;
+        /** Called when the submission flow throws — the round-trip, the submit
+         * itself, or `onsuccess`. The same error is kept as FormState.submitError,
+         * which <FormError> renders as a general error message. */
+        onerror?: (error: unknown) => void | Promise<void>;
+        /** Extra classes for the <form> element. */
+        class?: string;
+        /** Form content — the inputs and buttons that read this form's context. */
+        children: Snippet;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Input extends RemoteFormInput, Output> {
+    props(): ReturnType<typeof $$render<Input, Output>>['props'];
+    events(): ReturnType<typeof $$render<Input, Output>>['events'];
+    slots(): ReturnType<typeof $$render<Input, Output>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Input extends RemoteFormInput, Output>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Input, Output>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Input, Output>['props']>, ReturnType<__sveltets_Render<Input, Output>['events']>, ReturnType<__sveltets_Render<Input, Output>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Input, Output>['bindings']>;
+    } & ReturnType<__sveltets_Render<Input, Output>['exports']>;
+    <Input extends RemoteFormInput, Output>(internal: unknown, props: ReturnType<__sveltets_Render<Input, Output>['props']> & {}): ReturnType<__sveltets_Render<Input, Output>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+/**
+ * Wrapper around a SvelteKit remote form: enhances it and provides the context
+ * every `@privaty/ui-forms` input and button requires. With a `schema`, typing
+ * validates client-side (preflight); without one, validation is a debounced
+ * server round-trip. A field's issues stay hidden until it is touched or a
+ * submit is attempted; submission always validates server-side regardless.
+ */
+declare const Form: $$IsomorphicComponent;
+type Form<Input extends RemoteFormInput, Output> = InstanceType<typeof Form<Input, Output>>;
+export default Form;

package/dist/inputs/checkbox-input.svelte

@@ -0,0 +1,119 @@
+<!-- @component
+Checkbox wired to a SvelteKit remote form boolean 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. While submitting it locks interaction with CSS and
+key swallowing instead of disabling — a disabled checkbox is excluded from
+FormData and would silently submit as false.
+-->
+<script lang="ts">
+  import { cn } from "@privaty/ui/cn.js";
+  import Checkbox from "@privaty/ui/components/checkbox.svelte";
+  import type { CheckboxField } from "../types/field";
+  import { wireField } from "./wire-field";
+
+  interface Props {
+    /** The SvelteKit remote form field to bind. Structural — anything
+     * satisfying the CheckboxField slice works, e.g. a fake from the public
+     * testing subpath. */
+    field: CheckboxField;
+    /** Visible label text, rendered next to the box. */
+    label: string;
+
+    /** 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;
+    /**
+     * Checkboxes have no native readonly, so submitting locks interaction
+     * with CSS instead. NEVER disable while submitting: disabled controls are
+     * excluded from FormData — a checked box would silently submit as false.
+     */
+    disabled?: boolean;
+
+    /** Initial checked state (default false); native form reset restores
+     * it. */
+    initialValue?: boolean;
+
+    /** 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,
+
+    required = false,
+    disabled = false,
+
+    initialValue = false,
+
+    class: classes,
+    labelClass,
+    inputClass,
+    markerClass,
+    errorClass,
+  }: Props = $props();
+
+  // The seed rides Kit's as(): it supplies both `checked` and the
+  // `defaultChecked` getter (native reset restores the seed). Kit's
+  // defaultChecked is non-configurable — never add our own on top.
+  const attributes = $derived(field.as("checkbox", initialValue));
+
+  // 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(),
+    // Kit's field state: undefined = untouched (fall back to the seed);
+    // null = explicitly UNCHECKED (must not fall through to the seed).
+    getValue: () => {
+      const value = field.value();
+      return value === undefined ? initialValue : value;
+    },
+    setValue: (value) => field.set(value as boolean),
+    // Mid-edit Kit stores the raw DOM value: "on" when checked, null when
+    // unchecked.
+    normalize: (value) => value === true || value === "on",
+  });
+
+  // pointer-events-none blocks the mouse while submitting but not the
+  // keyboard — swallow value-changing keys too (Tab stays free).
+  function lockKeysWhileSubmitting(event: KeyboardEvent) {
+    if (!wired.state.isSubmitting) return;
+    if ([" ", "Enter"].includes(event.key)) {
+      event.preventDefault();
+    }
+  }
+</script>
+
+<Checkbox
+  {...attributes}
+  {label}
+  errors={wired.errors}
+  marker={wired.marker}
+  aria-invalid={wired.errors.length > 0 ? true : undefined}
+  onkeydown={lockKeysWhileSubmitting}
+  {disabled}
+  class={classes}
+  {labelClass}
+  inputClass={cn(wired.state.isSubmitting && "pointer-events-none", inputClass)}
+  markerClass={cn(required && "text-red-700 dark:text-red-500", markerClass)}
+  {errorClass}
+/>

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

@@ -0,0 +1,45 @@
+import type { CheckboxField } from "../types/field";
+interface Props {
+    /** The SvelteKit remote form field to bind. Structural — anything
+     * satisfying the CheckboxField slice works, e.g. a fake from the public
+     * testing subpath. */
+    field: CheckboxField;
+    /** Visible label text, rendered next to the box. */
+    label: string;
+    /** 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;
+    /**
+     * Checkboxes have no native readonly, so submitting locks interaction
+     * with CSS instead. NEVER disable while submitting: disabled controls are
+     * excluded from FormData — a checked box would silently submit as false.
+     */
+    disabled?: boolean;
+    /** Initial checked state (default false); native form reset restores
+     * it. */
+    initialValue?: boolean;
+    /** 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;
+}
+/**
+ * Checkbox wired to a SvelteKit remote form boolean 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. While submitting it locks interaction with CSS and
+ * key swallowing instead of disabling — a disabled checkbox is excluded from
+ * FormData and would silently submit as false.
+ */
+declare const CheckboxInput: import("svelte").Component<Props, {}, "">;
+type CheckboxInput = ReturnType<typeof CheckboxInput>;
+export default CheckboxInput;