attaform 0.17.2 → 0.18.1

package/dist/index.d.cts

@@ -1,187 +1,10 @@
-import { App, InjectionKey, Plugin } from 'vue';
-import { C as CoercionRegistry, S as SlimPrimitiveKind, a as CoercionEntry, A as AttaformDefaults, F as FormKey, G as GenericForm, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, d as UseFormReturnType, R as RegisterValue, e as RegisterModelDynamicCustomDirective, f as ShouldShowErrors, V as ValidationError, g as ApiErrorEnvelope, h as ApiErrorDetails } from './shared/attaform.C_5aB6EQ.cjs';
-export { i as ApiErrorEntry, j as ArrayItem, k as ArrayPath, l as CoercionResult, m as CustomDirectiveRegisterAssignerFn, n as DefaultValuesResponse, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, w as FormStorage, x as FormStorageKind, H as HandleSubmit, y as HistoryConfig, I as IsTuple, z as IsUnion, J as JoinSegments, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, E as OnInvalidSubmitPolicy, P as OnSubmit, Q as Path, T as PathKey, W as PendingValidationStatus, X as PersistConfig, Y as PersistConfigOptions, Z as PersistIncludeMode, _ as ROOT_PATH, $ as ROOT_PATH_KEY, a0 as ReactiveValidationStatus, a1 as RegisterDirective, a2 as RegisterFlatPath, a3 as RegisterOptions, a4 as RegisterSelectModifier, a5 as RegisterTextModifier, a6 as RegisterTransform, a7 as Segment, a8 as SetValueCallback, a9 as SetValuePayload, aa as SettledValidationStatus, ab as ShouldShowErrorsConfig, ac as SlimRuntimeOf, ad as SubmitHandler, ae as Unset, af as ValidateOn, ag as ValidateOnConfig, ah as ValidationResponse, ai as ValidationResponseWithoutValue, aj as ValueOfUnion, ak as WriteMeta, al as WriteShape, am as canonicalizePath, an as isPathPrefix, ao as isUnset, ap as parseDottedPath, aq as unset } from './shared/attaform.C_5aB6EQ.cjs';
-export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.C6qzEdIM.cjs';
+import { Plugin, App } from 'vue';
+import { S as SSRDetectOptions, a as SerializedFormData, A as AttaformRegistry } from './shared/attaform.DoSuaKMd.cjs';
+export { b as AggregateError, c as AnyForm, d as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, p as createRegistry, q as defaultCoercionRules, r as defineCoercion, s as getRegistryFromApp, t as injectForm, u as injectWizard, v as kAttaformRegistry, w as lazy, x as useRegister, y as useRegistry, z as useWizard } from './shared/attaform.DoSuaKMd.cjs';
+import { A as AttaformDefaults, F as FormKey, G as GenericForm, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, b as UseFormReturnType, R as RegisterValue, c as RegisterModelDynamicCustomDirective, S as Segment, d as ShouldShowErrors, V as ValidationError, e as ApiErrorEnvelope, f as ApiErrorDetails } from './shared/attaform.Dj9mwbaV.cjs';
+export { g as ApiErrorEntry, h as ArrayItem, i as ArrayPath, C as CoercionEntry, j as CoercionRegistry, k as CoercionResult, l as CustomDirectiveRegisterAssignerFn, m as DeepPartial, n as DefaultValuesResponse, o as DefaultValuesShape, E as ErrorsProxyShape, p as FieldMetaPayload, q as FieldState, r as FieldStateMap, s as FieldStateMapEntry, t as FlatPath, u as FormErrorRecord, v as FormErrorsSurface, w as FormMeta, x as FormStorage, y as FormStorageKind, H as HandleSubmit, z as HistoryConfig, I as IsTuple, B as IsUnion, J as JoinSegments, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, O as NestedType, P as OnError, Q as OnInvalidSubmitPolicy, T as OnSubmit, W as PartialFlatPath, X as Path, Y as PathKey, Z as PendingValidationStatus, _ as PersistConfig, $ as PersistConfigOptions, a0 as PersistIncludeMode, a1 as Primitive, a2 as ROOT_PATH, a3 as ROOT_PATH_KEY, a4 as ReactiveValidationStatus, a5 as RegisterDirective, a6 as RegisterFlatPath, a7 as RegisterOptions, a8 as RegisterSelectModifier, a9 as RegisterTextModifier, aa as RegisterTransform, ab as SetValueCallback, ac as SetValuePayload, ad as SettledValidationStatus, ae as ShouldShowErrorsConfig, af as SlimPrimitiveKind, ag as SlimRuntimeOf, ah as SubmitHandler, ai as Unset, aj as ValidateOn, ak as ValidateOnConfig, al as ValidationResponse, am as ValidationResponseWithoutValue, an as ValueOfUnion, ao as WriteMeta, ap as WriteShape, aq as canonicalizePath, ar as isPathPrefix, as as isUnset, at as parseDottedPath, au as unset } from './shared/attaform.Dj9mwbaV.cjs';
 export { A as AnonPersistError, a as AttaformError, I as InvalidPathError, b as InvalidUseFormConfigError, O as OutsideSetupError, R as RegistryNotInstalledError, c as ReservedFormKeyError, S as SensitivePersistFieldError, d as SubmitErrorHandlerError } from './shared/attaform.B7rzpK1U.cjs';
 
-/**
- * Schema-driven coercion of user-typed DOM values at the v-register
- * directive layer. When the slim schema declares a numeric or
- * boolean type at a path, the directive coerces incoming string
- * values (`'25'` → `25`, `'true'` → `true`) before the slim-primitive
- * gate sees the write — making the schema authoritative for storage
- * shape and freeing consumers from sprinkling `.number` modifiers
- * across templates.
- *
- * Coercion is consumer-extensible: a `CoercionRegistry` is just an
- * `Array<CoercionEntry>` keyed at config time by `(input, output)`
- * `SlimPrimitiveKind` literals. The library ships
- * `defaultCoercionRules` (string→number, string→boolean) and
- * `defineCoercion` for type-narrowed authoring; consumers spread the
- * defaults to extend or supply their own array to replace.
- *
- * Coercion applies ONLY to user-typed DOM values flowing through
- * the directive's assigner. Programmatic writes (`form.setValue`,
- * `setValueWithInternalPath`) bypass coercion — they're authoritative
- * writes whose strict typing is on the caller. This mirrors the
- * `transforms` pipeline's user-input-only contract.
- */
-
-/**
- * Type-narrowing helper for authoring entries. At runtime it's
- * identity; at compile time it preserves the `input` / `output`
- * literal types so `transform`'s parameter is narrowed to the
- * runtime type instead of widening to `SlimRuntimeOf<SlimPrimitiveKind>`.
- *
- * Without this helper, authoring `{ input: 'string', output:
- * 'number', transform: (s) => ... }` against the broader
- * `CoercionEntry` widens `s` to `string | number | boolean | ...`,
- * forcing a cast in every transform body. `defineCoercion` is the
- * opaque-free idiom.
- */
-declare function defineCoercion<I extends SlimPrimitiveKind, O extends SlimPrimitiveKind>(entry: CoercionEntry<I, O>): CoercionEntry<I, O>;
-/**
- * The library's built-in registry. Two cells: string→number and
- * string→boolean. Re-exported so consumers can spread it when
- * supplying a custom registry that extends defaults.
- */
-declare const defaultCoercionRules: CoercionRegistry;
-
-/**
- * Portable SSR detection. The plugin captures this value at install time and
- * exposes it via the registry so every runtime branch reads a single source
- * of truth instead of sniffing `import.meta.*` (bundler-specific) at each
- * call site.
- *
- * Consumers can override the heuristic explicitly via
- * `createAttaform({ ssr: true })`; the default handles the common
- * Node-vs-browser split without relying on any bundler-injected flag.
- */
-interface SSRDetectOptions {
-    /**
-     * Force SSR-vs-client mode, bypassing the `typeof window` heuristic.
-     * `true` activates the SSR code paths (no devtools, no persistence
-     * wiring, payload serialisation enabled); `false` forces client mode.
-     * The Nuxt plugin sets this from `import.meta.server` so SSR detection
-     * never depends on whether `window` is polyfilled. Tests that need to
-     * exercise the SSR code paths under jsdom pass `ssr: true`.
-     */
-    ssr?: boolean;
-}
-
-/**
- * Per-Vue-app container for all form state instances. Each
- * `app.use(createAttaform())` call gets its own registry,
- * so the library runs under bare Vue 3 + SSR (via
- * `@vue/server-renderer`) and Nuxt with the same code path.
- *
- * Each form's state lives in `forms: Map<FormKey, FormStore<GenericForm>>`.
- * The type relaxation at storage time is necessary because different
- * forms in the same app have different `Form` generics; callers recover
- * the specific form type via `useForm`'s overloads.
- */
-/**
- * Serialised snapshot of one form's state, captured by
- * `renderAttaformState` for SSR and replayed by
- * `hydrateAttaformState` on the client. Round-trips through
- * JSON-safe tuples; field references are intentionally omitted
- * (DOM nodes don't survive serialisation).
- */
-type SerializedFormData = {
-    /** The form's value at snapshot time. */
-    readonly form: unknown;
-    /**
-     * Errors produced by the schema at snapshot time. Replayed into
-     * the client form's error state at hydration; cleared on
-     * successful re-validation client-side.
-     */
-    readonly schemaErrors: ReadonlyArray<readonly [string, unknown]>;
-    /**
-     * Errors set explicitly via `setFieldErrors` / `addFieldErrors`
-     * (typically from a server response parsed via `parseApiErrors`)
-     * at snapshot time. Replayed at hydration; persists across
-     * client-side re-validation.
-     */
-    readonly userErrors: ReadonlyArray<readonly [string, unknown]>;
-    /** Per-field metadata (timestamps, raw values, connection flags) captured at snapshot time. */
-    readonly fields: ReadonlyArray<readonly [string, unknown]>;
-    /**
-     * Path keys that were in the form's `blankPaths` set at
-     * snapshot time. Round-trips the "displayed empty" UI state across
-     * the SSR boundary — without it, the client briefly renders
-     * `String(slim-default)` (e.g. `'0'`) for fields the server
-     * rendered as blank. Optional in the wire format so older payload
-     * shapes deserialise cleanly.
-     */
-    readonly blankPaths?: ReadonlyArray<string>;
-};
-/**
- * The library's per-Vue-app container. One `AttaformRegistry` is
- * created per `app.use(createAttaform())` call.
- *
- * Most consumers never touch this directly — `useForm` and
- * `injectForm` reach the registry on your behalf. Access it
- * explicitly only when wiring SSR or a custom plugin integration.
- */
-type AttaformRegistry = {
-    /** `true` while running on the server during SSR; `false` on the client. */
-    readonly ssr: boolean;
-    /** App-level defaults applied to every `useForm` call. */
-    readonly defaults: AttaformDefaults;
-};
-/**
- * The Vue `InjectionKey` under which the registry is provided on the
- * app. Most consumers never need this — `useForm` and
- * `injectForm` resolve the registry automatically.
- */
-declare const kAttaformRegistry: InjectionKey<AttaformRegistry>;
-declare module 'vue' {
-    interface App {
-    }
-}
-/** Options for `createRegistry`. */
-type CreateRegistryOptions = SSRDetectOptions & {
-    /**
-     * App-level defaults applied to every `useForm` call. Per-form
-     * options always win. Omitted is equivalent to `{}`.
-     */
-    defaults?: AttaformDefaults;
-};
-/**
- * Create a fresh `AttaformRegistry`. `createAttaform()` calls
- * this internally — most consumers never need to call it directly.
- * Use it when building a custom plugin that doesn't want the
- * `createAttaform` plugin's auto-install behaviour (e.g. test
- * harnesses, embedded apps).
- */
-declare function createRegistry(options?: CreateRegistryOptions): AttaformRegistry;
-/**
- * Look up the current app's registry from inside a component's
- * `setup()` (or any synchronous code on the setup call stack).
- *
- * Most consumers don't need this — `useForm` and `injectForm`
- * call it on your behalf. Reach for it directly when building
- * custom integrations that need the raw registry.
- *
- * Throws:
- * - `OutsideSetupError` when called outside a Vue setup context
- *   (e.g. from an event handler or async callback). Move the call
- *   into setup, or trigger it from a child component.
- * - `RegistryNotInstalledError` when called inside setup but the
- *   plugin wasn't installed. Add
- *   `app.use(createAttaform())` to your app entry.
- */
-declare function useRegistry(): AttaformRegistry;
-/**
- * Look up a Vue app's registry by `App` reference. Used by
- * SSR helpers (`renderAttaformState`, `hydrateAttaformState`) that
- * run outside a component setup context.
- *
- * Throws `RegistryNotInstalledError` when the app hasn't been wired
- * with `createAttaform()`.
- */
-declare function getRegistryFromApp(app: App): AttaformRegistry;
-
 /**
  * Options for `createAttaform()`.
  */
@@ -326,7 +149,19 @@ declare function escapeForInlineScript(json: string): string;
  * Returns the same form API as the typed entry points; see
  * `UseFormReturnType` for the full surface.
  */
-declare function useAbstractForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, ReadForm extends GenericForm = Form>(configuration: UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, DeepPartial<DefaultValuesShape<Form>>>): UseFormReturnType<Form, GetValueFormType, ReadForm>;
+declare function useAbstractForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, ReadForm extends GenericForm = Form, K extends FormKey = FormKey>(configuration: UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, DefaultValuesInput<Form>, K>, 
+/**
+ * Internal escape hatch for callers that already hold a registry
+ * reference and need to construct a form outside Vue's setup context
+ * (e.g. the wizard's lazy noop builder, which runs inside a
+ * `computed` re-eval). Passing this skips the strict `useRegistry()`
+ * call; everything else (FormStore allocation, registry presence,
+ * consumer ref-counting via `onScopeDispose`) goes through the same
+ * path eager calls follow. Not part of the public surface.
+ */
+options?: {
+    readonly registry?: AttaformRegistry;
+}): UseFormReturnType<Form, GetValueFormType, ReadForm, K>;
 
 /**
  * Symbol slot used by custom directive integrations to install an
@@ -370,28 +205,156 @@ declare function isRegisterValue<Value = unknown>(val: unknown): val is Register
  *
  * The directive picks the right binding strategy automatically based
  * on the element's `tagName` and `type`. Registered globally by
- * `createAttaform()` — most consumers never import it
- * directly, but it's exposed for advanced integrations that wire
- * directives manually.
+ * `createAttaform()`. Most consumers never import it directly, but
+ * it's exposed for advanced integrations that wire directives
+ * manually.
  */
 declare const vRegister: RegisterModelDynamicCustomDirective;
 
+/**
+ * Shared building blocks for Attaform's two devtools surfaces — the Vue
+ * DevTools (Chrome-extension) inspector wired up in `./devtools.ts`, and
+ * the Nuxt DevTools (overlay) panel wired up via `../../nuxt.ts` +
+ * `../pages/_attaform_devtools.vue`.
+ *
+ * Centralizing the redaction policy and the window-bridge contract here
+ * keeps both surfaces aligned: a future tightening of the sensitive-name
+ * heuristic, or a new field added to the bridge, lands in one file.
+ */
+
+declare const REDACTED = "[redacted]";
+/**
+ * Walk `value` and replace any leaf whose enclosing path matches the
+ * sensitive-name heuristic with the string `'[redacted]'`. Returns a
+ * new tree (no mutation of the input). Object keys + array indices are
+ * preserved; only the leaf payloads change.
+ *
+ * Applied to BOTH devtools surfaces' Form-value rendering AND every
+ * timeline event payload — leaks via either surface are treatable as
+ * "any developer with the panel open during user testing can read a
+ * customer's password," which is exactly the failure mode the
+ * sensitive-name guard exists to prevent on the storage side.
+ *
+ * Leaves whose path doesn't match a pattern pass through untouched.
+ * `acknowledgeSensitive: true` on persistence does NOT bypass this — if
+ * the consumer opted into persisting the value, they still shouldn't
+ * see it in DevTools timelines that grow unbounded.
+ *
+ * Implementation note: tracks an `inSensitiveSubtree` flag through the
+ * recursion instead of allocating a fresh path array per node + calling
+ * `isSensitivePath` per leaf. Once any ancestor segment matches the
+ * heuristic, the flag stays set for every descendant — the leaf simply
+ * returns `REDACTED` without re-scanning the path. For a 100-leaf form:
+ * ~100 path allocations + ~100 full-path regex sweeps → 0 path
+ * allocations + ~100 single-segment regex sweeps, with whole-subtree
+ * short-circuit when sensitive ancestors are found early.
+ */
+declare function redactSensitiveLeaves(value: unknown, matchSensitive: (segment: Segment) => boolean): unknown;
+/**
+ * Property key on `window` that the Nuxt-side dev plugin attaches the
+ * bridge object to. The iframe-mounted overlay panel reads
+ * `window.parent[DEVTOOLS_WINDOW_KEY]` to reach the host app's registry.
+ *
+ * Underscored + namespaced to make accidental collision with consumer
+ * globals vanishingly unlikely. Stable across versions — bumping it
+ * would silently disconnect older library builds from newer overlay
+ * panels in the same browser tab during a library upgrade.
+ */
+declare const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
+/**
+ * Shape of the object the host plugin attaches to `window` in dev mode.
+ * The iframe overlay panel reads this to discover the live registry and
+ * render its forms.
+ *
+ * Single-registry assumption: the latest `createAttaform()` install
+ * wins. Multi-app pages (rare; typically only seen in micro-frontend
+ * setups) will only see one app's forms in the panel. Documented but
+ * not actively supported — the alternative (a Set of registries with
+ * union-rendering) is a future call if a real consumer hits it.
+ */
+interface AttaformDevtoolsBridge {
+    registry: AttaformRegistry;
+    /**
+     * The library version, surfaced in the panel's footer for support /
+     * bug-report context. Read from `package.json` at host-plugin init.
+     */
+    version: string;
+}
+declare global {
+    interface Window {
+        [DEVTOOLS_WINDOW_KEY]?: AttaformDevtoolsBridge;
+    }
+}
+
 /**
  * Library-default heuristic for `shouldShowErrors`. Drives
  * `field.showErrors` and `form.meta.showErrors` whenever the consumer
  * has not configured an override at either the plugin or per-form
  * level.
  *
- * Reads "show errors after the first submit attempt, OR after the
- * user has interacted (`touched`) and made a change (`dirty`)." The
- * framework already gates on `errors.length > 0` before invoking the
- * predicate, so the body only decides *when* to surface existing
- * errors — not whether errors exist.
+ * Four clauses: the first two are hard gates; clause 3 is an
+ * aggressive override after the first submit attempt; clause 4 is
+ * the pre-submit timing gate.
+ *
+ * 1. **Own-path filter.** The field must have at least one error whose
+ *    path equals the field's own path. Leaves always satisfy this when
+ *    they have errors. Containers (intermediate or root) only satisfy
+ *    it for errors that point directly at them, so a UI rendering
+ *    `field.showErrors` at a container never duplicates errors that a
+ *    more-specific descendant will already render. Aggregate banners
+ *    that want "any error anywhere passed the gate" should bind to
+ *    `form.meta.errorCount > 0` (paired with whatever timing signal
+ *    fits), not to `form.meta.showErrors`.
+ *
+ * 2. **Not currently validating.** While the field is mid-revalidation
+ *    (`field.validating === true`) the verdict in `field.errors` is
+ *    stale by definition. The error itself stays in the store under
+ *    the stale-while-revalidate contract so the surface doesn't
+ *    flicker to empty, but the UX gate hides it: the application is
+ *    actively re-checking, so the message would mis-narrate the
+ *    state of the world. Containers roll up `validating` as a
+ *    disjunction, so any descendant under revalidation hides the
+ *    container's `showErrors` too. The error returns the moment the
+ *    new verdict lands and `validating` flips back to false.
+ *
+ * 3. **Post-submit override.** Once `formMeta.submissionAttempts > 0`
+ *    the heuristic surfaces every own-path error unconditionally on
+ *    the field axis (subject only to the two gates above). The
+ *    counter covers two distinct gestures:
+ *
+ *    - `form.handleSubmit` directly, or `wizard.handleSubmit` at an
+ *      intermediate step. The user asked this specific form to
+ *      commit; transient mid-edit hiding is no longer appropriate.
+ *
+ *    - `wizard.handleSubmit` at the final step. The wizard validates
+ *      every form in parallel and bumps each one's `submissionAttempts`,
+ *      so a `Finish`-button submission reveals errors across the
+ *      whole multistep flow at once. That's the review-surface UX:
+ *      by the time the user tries to commit the wizard, every
+ *      blocking error lights up regardless of which step it lives on.
+ *
+ *    The arm deliberately covers focused, pristine, and untouched
+ *    fields, so the next paint after the user tried to progress lights
+ *    up every problem the validator found.
+ *
+ * 4. **Pre-submit timing gate.** Before the first submit attempt,
+ *    show once the user has touched the field (sticky-true after the
+ *    first blur) AND is not currently focused on it. The not-focused
+ *    half hides transient errors while the user is actively editing
+ *    the field; they reappear when the user blurs (or focuses a
+ *    sibling). This deliberately includes blur-without-typing on a
+ *    required field (touched flips on blur regardless of `dirty`), so
+ *    a user who visits an empty required field and moves on sees the
+ *    error.
+ *
+ * The framework already gates on `errors.length > 0` before invoking
+ * the predicate, so the body only decides *when* to surface existing
+ * errors, not whether errors exist.
  *
  * Public re-export so adopters can compose with this without
- * copy-pasting the rule body. A layered predicate that adds a
- * special case but otherwise defers to the library default picks up
- * future heuristic refinements automatically:
+ * copy-pasting the rule body. A layered predicate that adds a special
+ * case but otherwise defers to the library default picks up future
+ * heuristic refinements automatically:
  *
  * ```ts
  * import { defaultShouldShowErrors } from 'attaform'
@@ -566,5 +529,5 @@ declare const PARSE_API_ERRORS_DEFAULTS: {
  */
 declare function parseApiErrors(payload: ApiErrorEnvelope | ApiErrorDetails | null | undefined | unknown, options: ParseApiErrorsOptions): ParseApiErrorsResult;
 
-export { AbstractSchema, ApiErrorDetails, ApiErrorEnvelope, AttaformDefaults, CoercionEntry, CoercionRegistry, DEFAULT_SENSITIVE_NAMES, DeepPartial, DefaultValuesShape, FormKey, GenericForm, PARSE_API_ERRORS_DEFAULTS, RegisterValue, ShouldShowErrors, SlimPrimitiveKind, UseFormConfiguration, UseFormReturnType, ValidationError, assignKey, createAttaform, createRegistry, defaultCoercionRules, defaultShouldShowErrors, defineCoercion, escapeForInlineScript, getRegistryFromApp, hydrateAttaformState, isRegisterValue, kAttaformRegistry, parseApiErrors, renderAttaformState, useAbstractForm as useForm, useRegistry, vRegister };
-export type { AttaformPluginOptions, AttaformRegistry, ParseApiErrorsOptions, ParseApiErrorsResult, SerializedAttaformState, SerializedFormData };
+export { AbstractSchema, ApiErrorDetails, ApiErrorEnvelope, AttaformDefaults, AttaformRegistry, DEFAULT_SENSITIVE_NAMES, DEVTOOLS_WINDOW_KEY, DefaultValuesInput, FormKey, GenericForm, PARSE_API_ERRORS_DEFAULTS, REDACTED, RegisterValue, Segment, SerializedFormData, ShouldShowErrors, UseFormConfiguration, UseFormReturnType, ValidationError, assignKey, createAttaform, defaultShouldShowErrors, escapeForInlineScript, hydrateAttaformState, isRegisterValue, parseApiErrors, redactSensitiveLeaves, renderAttaformState, useAbstractForm as useForm, vRegister };
+export type { AttaformDevtoolsBridge, AttaformPluginOptions, ParseApiErrorsOptions, ParseApiErrorsResult, SerializedAttaformState };