@angular/forms 21.2.0-next.1 → 21.2.0-next.2

package/types/_structure-chunk.d.ts

@@ -1,13 +1,13 @@
 /**
- * @license Angular v21.2.0-next.1
+ * @license Angular v21.2.0-next.2
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
 
 import * as i0 from '@angular/core';
-import { Signal, ɵFieldState as _FieldState, ɵFormFieldBindingOptions as _FormFieldBindingOptions, InjectionToken, Injector, ɵCONTROL as _CONTROL, ɵɵcontrolCreate as __controlCreate, ɵcontrolUpdate as _controlUpdate, Provider, WritableSignal, DestroyableInjector } from '@angular/core';
+import { Signal, WritableSignal, InjectionToken, Injector, Provider } from '@angular/core';
 import * as _angular_forms from '@angular/forms';
-import { AbstractControl, NgControl, ValidationErrors, FormControlStatus, ControlValueAccessor, ValidatorFn } from '@angular/forms';
+import { AbstractControl, ValidationErrors, FormControlStatus, ControlValueAccessor, ValidatorFn } from '@angular/forms';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
 /**
@@ -176,6 +176,70 @@ declare const MAX_LENGTH: MetadataKey<Signal<number | undefined>, number | undef
  */
 declare const PATTERN: MetadataKey<Signal<RegExp[]>, RegExp | undefined, RegExp[]>;
 
+/**
+ * Utility type that removes a string index key when its value is `unknown`,
+ * i.e. `{[key: string]: unknown}`. It allows specific string keys to pass through, even if their
+ * value is `unknown`, e.g. `{key: unknown}`.
+ *
+ * @experimental 21.0.0
+ */
+type RemoveStringIndexUnknownKey<K, V> = string extends K ? unknown extends V ? never : K : K;
+/**
+ * Utility type that recursively ignores unknown string index properties on the given object.
+ * We use this on the `TSchema` type in `validateStandardSchema` in order to accommodate Zod's
+ * `looseObject` which includes `{[key: string]: unknown}` as part of the type.
+ *
+ * @experimental 21.0.0
+ */
+type IgnoreUnknownProperties<T> = T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T as RemoveStringIndexUnknownKey<K, T[K]>]: IgnoreUnknownProperties<T[K]>;
+} : T;
+/**
+ * Validates a field using a `StandardSchemaV1` compatible validator (e.g. a Zod validator).
+ *
+ * See https://github.com/standard-schema/standard-schema for more about standard schema.
+ *
+ * @param path The `FieldPath` to the field to validate.
+ * @param schema The standard schema compatible validator to use for validation.
+ * @template TSchema The type validated by the schema. This may be either the full `TValue` type,
+ *   or a partial of it.
+ * @template TValue The type of value stored in the field being validated.
+ *
+ * @see [Signal Form Schema Validation](guide/forms/signals/validation#integration-with-schema-validation-libraries)
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function validateStandardSchema<TSchema, TModel extends IgnoreUnknownProperties<TSchema>>(path: SchemaPath<TModel> & SchemaPathTree<TModel>, schema: StandardSchemaV1<TSchema>): void;
+/**
+ * Create a standard schema issue error associated with the target field
+ * @param issue The standard schema issue
+ * @param options The validation error options
+ *
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function standardSchemaError(issue: StandardSchemaV1.Issue, options: WithFieldTree<ValidationErrorOptions>): StandardSchemaValidationError;
+/**
+ * Create a standard schema issue error
+ * @param issue The standard schema issue
+ * @param options The optional validation error options
+ *
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function standardSchemaError(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions): WithoutFieldTree<StandardSchemaValidationError>;
+/**
+ * An error used to indicate an issue validating against a standard schema.
+ *
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare class StandardSchemaValidationError extends BaseNgValidationError {
+    readonly issue: StandardSchemaV1.Issue;
+    readonly kind = "standardSchema";
+    constructor(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions);
+}
+
 /**
  * Symbol used to retain generic type information when it would otherwise be lost.
  */
@@ -333,7 +397,64 @@ type MaybeFieldTree<TModel, TKey extends string | number = string | number> = (T
  * @category structure
  * @experimental 21.0.0
  */
-interface FieldState<TValue, TKey extends string | number = string | number> extends _FieldState<TValue> {
+interface FieldState<TValue, TKey extends string | number = string | number> {
+    /**
+     * A writable signal containing the value for this field.
+     *
+     * Updating this signal will update the data model that the field is bound to.
+     *
+     * While updates from the UI control are eventually reflected here, they may be delayed if
+     * debounced.
+     */
+    readonly value: WritableSignal<TValue>;
+    /**
+     * A signal indicating whether the field is currently disabled.
+     */
+    readonly disabled: Signal<boolean>;
+    /**
+     * A signal indicating the field's maximum value, if applicable.
+     *
+     * Applies to `<input>` with a numeric or date `type` attribute and custom controls.
+     */
+    readonly max?: Signal<number | undefined>;
+    /**
+     * A signal indicating the field's maximum string length, if applicable.
+     *
+     * Applies to `<input>`, `<textarea>`, and custom controls.
+     */
+    readonly maxLength?: Signal<number | undefined>;
+    /**
+     * A signal indicating the field's minimum value, if applicable.
+     *
+     * Applies to `<input>` with a numeric or date `type` attribute and custom controls.
+     */
+    readonly min?: Signal<number | undefined>;
+    /**
+     * A signal indicating the field's minimum string length, if applicable.
+     *
+     * Applies to `<input>`, `<textarea>`, and custom controls.
+     */
+    readonly minLength?: Signal<number | undefined>;
+    /**
+     * A signal of a unique name for the field, by default based on the name of its parent field.
+     */
+    readonly name: Signal<string>;
+    /**
+     * A signal indicating the patterns the field must match.
+     */
+    readonly pattern: Signal<readonly RegExp[]>;
+    /**
+     * A signal indicating whether the field is currently readonly.
+     */
+    readonly readonly: Signal<boolean>;
+    /**
+     * A signal indicating whether the field is required.
+     */
+    readonly required: Signal<boolean>;
+    /**
+     * A signal indicating whether the field has been touched by the user.
+     */
+    readonly touched: Signal<boolean>;
     /**
      * A signal indicating whether field value has been changed by user.
      */
@@ -398,6 +519,22 @@ interface FieldState<TValue, TKey extends string | number = string | number> ext
      * The {@link FormField} directives that bind this field to a UI control.
      */
     readonly formFieldBindings: Signal<readonly FormField<unknown>[]>;
+    /**
+     * A signal containing the value of the control to which this field is bound.
+     *
+     * This differs from {@link value} in that it's not subject to debouncing, and thus is used to
+     * buffer debounced updates from the control to the field. This will also not take into account
+     * the {@link controlValue} of children.
+     */
+    readonly controlValue: WritableSignal<TValue>;
+    /**
+     * Sets the dirty status of the field to `true`.
+     */
+    markAsDirty(): void;
+    /**
+     * Sets the touched status of the field to `true`.
+     */
+    markAsTouched(): void;
     /**
      * Reads a metadata value from the field.
      * @param key The metadata key to read.
@@ -687,9 +824,29 @@ type ItemType<T extends Object> = T extends ReadonlyArray<any> ? T[number] : T[k
 type Debouncer<TValue, TPathKind extends PathKind = PathKind.Root> = (context: FieldContext<TValue, TPathKind>, abortSignal: AbortSignal) => Promise<void> | void;
 
 /**
- * Properties of both NgControl & AbstractControl that are supported by the InteropNgControl.
- */
-type InteropSharedKeys = 'value' | 'valid' | 'invalid' | 'touched' | 'untouched' | 'disabled' | 'enabled' | 'errors' | 'pristine' | 'dirty' | 'status';
+ * Represents a combination of `NgControl` and `AbstractControl`.
+ *
+ * Note: We have this separate interface, rather than implementing the relevant parts of the two
+ * controls with something like `InteropNgControl implements Pick<NgControl, ...>, Pick<AbstractControl, ...>`
+ * because it confuses the internal JS minifier which can cause collisions in field names.
+ */
+interface CombinedControl {
+    value: any;
+    valid: boolean;
+    invalid: boolean;
+    touched: boolean;
+    untouched: boolean;
+    disabled: boolean;
+    enabled: boolean;
+    errors: ValidationErrors | null;
+    pristine: boolean;
+    dirty: boolean;
+    status: FormControlStatus;
+    control: AbstractControl<any, any>;
+    valueAccessor: ControlValueAccessor | null;
+    hasValidator(validator: ValidatorFn): boolean;
+    updateValueAndValidity(): void;
+}
 /**
  * A fake version of `NgControl` provided by the `Field` directive. This allows interoperability
  * with a wider range of components designed to work with reactive forms, in particular ones that
@@ -697,7 +854,7 @@ type InteropSharedKeys = 'value' | 'valid' | 'invalid' | 'touched' | 'untouched'
  * the real `NgControl`, but does implement some of the most commonly used ones that have a clear
  * equivalent in signal forms.
  */
-declare class InteropNgControl implements Pick<NgControl, InteropSharedKeys | 'control' | 'valueAccessor'>, Pick<AbstractControl<unknown>, InteropSharedKeys | 'hasValidator'> {
+declare class InteropNgControl implements CombinedControl {
     protected field: () => FieldState<unknown>;
     constructor(field: () => FieldState<unknown>);
     readonly control: AbstractControl<any, any>;
@@ -718,14 +875,18 @@ declare class InteropNgControl implements Pick<NgControl, InteropSharedKeys | 'c
     updateValueAndValidity(): void;
 }
 
-interface FormFieldBindingOptions<TValue> extends _FormFieldBindingOptions {
+declare const ɵNgFieldDirective: unique symbol;
+interface FormFieldBindingOptions {
     /**
      * Focuses the binding.
      *
      * If not specified, Signal Forms will attempt to focus the host element of the `FormField` when
      * asked to focus this binding.
      */
-    focus?(options?: FocusOptions): void;
+    readonly focus?: (focusOptions?: FocusOptions) => void;
+    /**
+     * Source of parse errors for this binding.
+     */
     readonly parseErrors?: Signal<ValidationError.WithoutFieldTree[]>;
 }
 /**
@@ -755,33 +916,64 @@ declare const FORM_FIELD: InjectionToken<FormField<unknown>>;
  * @experimental 21.0.0
  */
 declare class FormField<T> {
-    readonly element: HTMLElement;
-    readonly injector: Injector;
     readonly fieldTree: i0.InputSignal<FieldTree<T>>;
+    /**
+     * `FieldState` for the currently bound field.
+     */
     readonly state: Signal<[T] extends [_angular_forms.AbstractControl<any, any, any>] ? CompatFieldState<T, string | number> : FieldState<T, string | number>>;
-    private readonly bindingOptions;
-    /** Errors associated with this form field. */
-    readonly errors: Signal<ValidationError.WithFieldTree[]>;
-    readonly [_CONTROL]: {
-        readonly create: typeof __controlCreate;
-        readonly update: typeof _controlUpdate;
-    };
-    private config;
+    /**
+     * The node injector for the element this field binding.
+     */
+    readonly injector: Injector;
+    /**
+     * The DOM element hosting this field binding.
+     */
+    readonly element: HTMLElement;
+    private readonly elementIsNativeFormElement;
+    private readonly elementAcceptsNumericValues;
+    private readonly elementAcceptsTextualValues;
+    /**
+     * Current focus implementation, set by `registerAsBinding`.
+     */
+    private focuser;
     /** Any `ControlValueAccessor` instances provided on the host element. */
     private readonly controlValueAccessors;
+    private readonly config;
+    private readonly parseErrorsSource;
     /** A lazily instantiated fake `NgControl`. */
-    private interopNgControl;
+    private _interopNgControl;
     /** Lazily instantiates a fake `NgControl` for this form field. */
-    protected getOrCreateNgControl(): InteropNgControl;
+    protected get interopNgControl(): InteropNgControl;
+    /** Errors associated with this form field. */
+    readonly errors: Signal<ValidationError.WithFieldTree[]>;
+    /** Whether this `FormField` has been registered as a binding on its associated `FieldState`. */
+    private isFieldBinding;
+    /**
+     * Creates an `afterRenderEffect` that applies the configured class bindings to the host element
+     * if needed.
+     */
+    private installClassBindingEffect;
+    /**
+     * Focuses this field binding.
+     *
+     * By default, this will focus the host DOM element. However, custom `FormUiControl`s can
+     * implement custom focusing behavior.
+     */
+    focus(options?: FocusOptions): void;
     /**
      * Registers this `FormField` as a binding on its associated `FieldState`.
      *
      * This method should be called at most once for a given `FormField`. A `FormField` placed on a
      * custom control (`FormUiControl`) automatically registers that custom control as a binding.
      */
-    registerAsBinding(bindingOptions?: FormFieldBindingOptions<T>): void;
-    /** Focuses this UI control. */
-    focus(options?: FocusOptions): void;
+    registerAsBinding(bindingOptions?: FormFieldBindingOptions): void;
+    /**
+     * The presence of this symbol tells the template type-checker that this directive is a control
+     * directive and should be type-checked as such. We don't use the `ɵngControlCreate` method below
+     * as it's marked internal and removed from the public API. A symbol is used instead to avoid
+     * polluting the public API with the marker.
+     */
+    readonly [ɵNgFieldDirective]: true;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormField<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FormField<any>, "[formField]", ["formField"], { "fieldTree": { "alias": "formField"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -947,24 +1139,6 @@ declare function emailError(options: WithFieldTree<ValidationErrorOptions>): Ema
  * @experimental 21.0.0
  */
 declare function emailError(options?: ValidationErrorOptions): WithoutFieldTree<EmailValidationError>;
-/**
- * Create a standard schema issue error associated with the target field
- * @param issue The standard schema issue
- * @param options The validation error options
- *
- * @category validation
- * @experimental 21.0.0
- */
-declare function standardSchemaError(issue: StandardSchemaV1.Issue, options: WithFieldTree<ValidationErrorOptions>): StandardSchemaValidationError;
-/**
- * Create a standard schema issue error
- * @param issue The standard schema issue
- * @param options The optional validation error options
- *
- * @category validation
- * @experimental 21.0.0
- */
-declare function standardSchemaError(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions): WithoutFieldTree<StandardSchemaValidationError>;
 /**
  * Common interface for all validation errors.
  *
@@ -1035,7 +1209,7 @@ declare namespace ValidationError {
  *
  * @experimental 21.0.0
  */
-declare abstract class _NgValidationError implements ValidationError {
+declare abstract class BaseNgValidationError implements ValidationError {
     /** Brand the class to avoid Typescript structural matching */
     private __brand;
     /** Identifies the kind of error. */
@@ -1052,7 +1226,7 @@ declare abstract class _NgValidationError implements ValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class RequiredValidationError extends _NgValidationError {
+declare class RequiredValidationError extends BaseNgValidationError {
     readonly kind = "required";
 }
 /**
@@ -1061,7 +1235,7 @@ declare class RequiredValidationError extends _NgValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class MinValidationError extends _NgValidationError {
+declare class MinValidationError extends BaseNgValidationError {
     readonly min: number;
     readonly kind = "min";
     constructor(min: number, options?: ValidationErrorOptions);
@@ -1072,7 +1246,7 @@ declare class MinValidationError extends _NgValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class MaxValidationError extends _NgValidationError {
+declare class MaxValidationError extends BaseNgValidationError {
     readonly max: number;
     readonly kind = "max";
     constructor(max: number, options?: ValidationErrorOptions);
@@ -1083,7 +1257,7 @@ declare class MaxValidationError extends _NgValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class MinLengthValidationError extends _NgValidationError {
+declare class MinLengthValidationError extends BaseNgValidationError {
     readonly minLength: number;
     readonly kind = "minLength";
     constructor(minLength: number, options?: ValidationErrorOptions);
@@ -1094,7 +1268,7 @@ declare class MinLengthValidationError extends _NgValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class MaxLengthValidationError extends _NgValidationError {
+declare class MaxLengthValidationError extends BaseNgValidationError {
     readonly maxLength: number;
     readonly kind = "maxLength";
     constructor(maxLength: number, options?: ValidationErrorOptions);
@@ -1105,7 +1279,7 @@ declare class MaxLengthValidationError extends _NgValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class PatternValidationError extends _NgValidationError {
+declare class PatternValidationError extends BaseNgValidationError {
     readonly pattern: RegExp;
     readonly kind = "pattern";
     constructor(pattern: RegExp, options?: ValidationErrorOptions);
@@ -1116,20 +1290,9 @@ declare class PatternValidationError extends _NgValidationError {
  * @category validation
  * @experimental 21.0.0
  */
-declare class EmailValidationError extends _NgValidationError {
+declare class EmailValidationError extends BaseNgValidationError {
     readonly kind = "email";
 }
-/**
- * An error used to indicate an issue validating against a standard schema.
- *
- * @category validation
- * @experimental 21.0.0
- */
-declare class StandardSchemaValidationError extends _NgValidationError {
-    readonly issue: StandardSchemaV1.Issue;
-    readonly kind = "standardSchema";
-    constructor(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions);
-}
 /**
  * The base class for all built-in, non-custom errors. This class can be used to check if an error
  * is one of the standard kinds, allowing you to switch on the kind to further narrow the type.
@@ -1176,992 +1339,40 @@ interface SignalFormsConfig {
  */
 declare function provideSignalFormsConfig(config: SignalFormsConfig): Provider[];
 
-/** Represents a result that should be ignored because its predicate indicates it is not active. */
-declare const IGNORED: unique symbol;
-/**
- * A predicate that indicates whether an `AbstractLogic` instance is currently active, or should be
- * ignored.
- */
-interface Predicate {
-    /** A boolean logic function that returns true if the logic is considered active. */
-    readonly fn: LogicFn<any, boolean>;
-    /**
-     * The path which this predicate was created for. This is used to determine the correct
-     * `FieldContext` to pass to the predicate function.
-     */
-    readonly path: SchemaPath<any>;
-}
-/**
- * Represents a predicate that is bound to a particular depth in the field tree. This is needed for
- * recursively applied logic to ensure that the predicate is evaluated against the correct
- * application of that logic.
- *
- * Consider the following example:
- *
- * ```ts
- * const s = schema(p => {
- *   disabled(p.data);
- *   applyWhen(p.next, ({valueOf}) => valueOf(p.data) === 1, s);
- * });
- *
- * const f = form(signal({data: 0, next: {data: 1, next: {data: 2, next: undefined}}}), s);
- *
- * const isDisabled = f.next.next.data().disabled();
- * ```
- *
- * In order to determine `isDisabled` we need to evaluate the predicate from `applyWhen` *twice*.
- * Once to see if the schema should be applied to `f.next` and again to see if it should be applied
- * to `f.next.next`. The `depth` tells us which field we should be evaluating against each time.
- */
-interface BoundPredicate extends Predicate {
-    /** The depth in the field tree at which this predicate is bound. */
-    readonly depth: number;
-}
-/**
- * Base class for all logic. It is responsible for combining the results from multiple individual
- * logic functions registered in the schema, and using them to derive the value for some associated
- * piece of field state.
- */
-declare abstract class AbstractLogic<TReturn, TValue = TReturn> {
-    /**
-     * A list of predicates that conditionally enable all logic in this logic instance.
-     * The logic is only enabled when *all* of the predicates evaluate to true.
-     */
-    private predicates;
-    /** The set of logic functions that contribute to the value of the associated state. */
-    protected readonly fns: Array<LogicFn<any, TValue | typeof IGNORED>>;
-    constructor(
-    /**
-     * A list of predicates that conditionally enable all logic in this logic instance.
-     * The logic is only enabled when *all* of the predicates evaluate to true.
-     */
-    predicates: ReadonlyArray<BoundPredicate>);
-    /**
-     * Computes the value of the associated field state based on the logic functions and predicates
-     * registered with this logic instance.
-     */
-    abstract compute(arg: FieldContext<any>): TReturn;
-    /**
-     * The default value that the associated field state should assume if there are no logic functions
-     * registered by the schema (or if the logic is disabled by a predicate).
-     */
-    abstract get defaultValue(): TReturn;
-    /** Registers a logic function with this logic instance. */
-    push(logicFn: LogicFn<any, TValue>): void;
-    /**
-     * Merges in the logic from another logic instance, subject to the predicates of both the other
-     * instance and this instance.
-     */
-    mergeIn(other: AbstractLogic<TReturn, TValue>): void;
-}
-/** Logic that combines its individual logic function results with logical OR. */
-declare class BooleanOrLogic extends AbstractLogic<boolean> {
-    get defaultValue(): boolean;
-    compute(arg: FieldContext<any>): boolean;
-}
-/**
- * Logic that combines its individual logic function results by aggregating them in an array.
- * Depending on its `ignore` function it may ignore certain values, omitting them from the array.
- */
-declare class ArrayMergeIgnoreLogic<TElement, TIgnore = never> extends AbstractLogic<readonly TElement[], TElement | readonly (TElement | TIgnore)[] | TIgnore | undefined | void> {
-    private ignore;
-    /** Creates an instance of this class that ignores `null` values. */
-    static ignoreNull<TElement>(predicates: ReadonlyArray<BoundPredicate>): ArrayMergeIgnoreLogic<TElement, null>;
-    constructor(predicates: ReadonlyArray<BoundPredicate>, ignore: undefined | ((e: TElement | undefined | TIgnore) => e is TIgnore));
-    get defaultValue(): never[];
-    compute(arg: FieldContext<any>): readonly TElement[];
-}
-/** Logic that combines its individual logic function results by aggregating them in an array. */
-declare class ArrayMergeLogic<TElement> extends ArrayMergeIgnoreLogic<TElement, never> {
-    constructor(predicates: ReadonlyArray<BoundPredicate>);
-}
-/**
- * Container for all the different types of logic that can be applied to a field
- * (disabled, hidden, errors, etc.)
- */
-declare class LogicContainer {
-    private predicates;
-    /** Logic that determines if the field is hidden. */
-    readonly hidden: BooleanOrLogic;
-    /** Logic that determines reasons for the field being disabled. */
-    readonly disabledReasons: ArrayMergeLogic<DisabledReason>;
-    /** Logic that determines if the field is read-only. */
-    readonly readonly: BooleanOrLogic;
-    /** Logic that produces synchronous validation errors for the field. */
-    readonly syncErrors: ArrayMergeIgnoreLogic<ValidationError.WithFieldTree, null>;
-    /** Logic that produces synchronous validation errors for the field's subtree. */
-    readonly syncTreeErrors: ArrayMergeIgnoreLogic<ValidationError.WithFieldTree, null>;
-    /** Logic that produces asynchronous validation results (errors or 'pending'). */
-    readonly asyncErrors: ArrayMergeIgnoreLogic<ValidationError.WithFieldTree | 'pending', null>;
-    /** A map of metadata keys to the `AbstractLogic` instances that compute their values. */
-    private readonly metadata;
-    /**
-     * Constructs a new `Logic` container.
-     * @param predicates An array of predicates that must all be true for the logic
-     *   functions within this container to be active.
-     */
-    constructor(predicates: ReadonlyArray<BoundPredicate>);
-    /** Checks whether there is logic for the given metadata key. */
-    hasMetadata(key: MetadataKey<any, any, any>): boolean;
-    /**
-     * Gets an iterable of [metadata key, logic function] pairs.
-     * @returns An iterable of metadata keys.
-     */
-    getMetadataKeys(): MapIterator<MetadataKey<unknown, unknown, unknown>>;
-    /**
-     * Retrieves or creates the `AbstractLogic` for a given metadata key.
-     * @param key The `MetadataKey` for which to get the logic.
-     * @returns The `AbstractLogic` associated with the key.
-     */
-    getMetadata<T>(key: MetadataKey<any, T, any>): AbstractLogic<T>;
-    /**
-     * Merges logic from another `Logic` instance into this one.
-     * @param other The `Logic` instance to merge from.
-     */
-    mergeIn(other: LogicContainer): void;
-}
-
-/**
- * Abstract base class for building a `LogicNode`.
- * This class defines the interface for adding various logic rules (e.g., hidden, disabled)
- * and data factories to a node in the logic tree.
- * LogicNodeBuilders are 1:1 with nodes in the Schema tree.
- */
-declare abstract class AbstractLogicNodeBuilder {
-    /** The depth of this node in the schema tree. */
-    protected readonly depth: number;
-    constructor(
-    /** The depth of this node in the schema tree. */
-    depth: number);
-    /** Adds a rule to determine if a field should be hidden. */
-    abstract addHiddenRule(logic: LogicFn<any, boolean>): void;
-    /** Adds a rule to determine if a field should be disabled, and for what reason. */
-    abstract addDisabledReasonRule(logic: LogicFn<any, DisabledReason | undefined>): void;
-    /** Adds a rule to determine if a field should be read-only. */
-    abstract addReadonlyRule(logic: LogicFn<any, boolean>): void;
-    /** Adds a rule for synchronous validation errors for a field. */
-    abstract addSyncErrorRule(logic: LogicFn<any, ValidationResult>): void;
-    /** Adds a rule for synchronous validation errors that apply to a subtree. */
-    abstract addSyncTreeErrorRule(logic: LogicFn<any, ValidationResult>): void;
-    /** Adds a rule for asynchronous validation errors for a field. */
-    abstract addAsyncErrorRule(logic: LogicFn<any, AsyncValidationResult>): void;
-    /** Adds a rule to compute metadata for a field. */
-    abstract addMetadataRule<M>(key: MetadataKey<unknown, M, unknown>, logic: LogicFn<any, M>): void;
-    /**
-     * Gets a builder for a child node associated with the given property key.
-     * @param key The property key of the child.
-     * @returns A `LogicNodeBuilder` for the child.
-     */
-    abstract getChild(key: PropertyKey): LogicNodeBuilder;
-    /**
-     * Checks whether a particular `AbstractLogicNodeBuilder` has been merged into this one.
-     * @param builder The builder to check for.
-     * @returns True if the builder has been merged, false otherwise.
-     */
-    abstract hasLogic(builder: AbstractLogicNodeBuilder): boolean;
-    /**
-     * Builds the `LogicNode` from the accumulated rules and child builders.
-     * @returns The constructed `LogicNode`.
-     */
-    build(): LogicNode;
-}
-/**
- * A builder for `LogicNode`. Used to add logic to the final `LogicNode` tree.
- * This builder supports merging multiple sources of logic, potentially with predicates,
- * preserving the order of rule application.
- */
-declare class LogicNodeBuilder extends AbstractLogicNodeBuilder {
-    constructor(depth: number);
-    /**
-     * The current `NonMergeableLogicNodeBuilder` being used to add rules directly to this
-     * `LogicNodeBuilder`. Do not use this directly, call `getCurrent()` which will create a current
-     * builder if there is none.
-     */
-    private current;
-    /**
-     * Stores all builders that contribute to this node, along with any predicates
-     * that gate their application.
-     */
-    readonly all: {
-        builder: AbstractLogicNodeBuilder;
-        predicate?: Predicate;
-    }[];
-    addHiddenRule(logic: LogicFn<any, boolean>): void;
-    addDisabledReasonRule(logic: LogicFn<any, DisabledReason | undefined>): void;
-    addReadonlyRule(logic: LogicFn<any, boolean>): void;
-    addSyncErrorRule(logic: LogicFn<any, ValidationResult<ValidationError.WithFieldTree>>): void;
-    addSyncTreeErrorRule(logic: LogicFn<any, ValidationResult<ValidationError.WithFieldTree>>): void;
-    addAsyncErrorRule(logic: LogicFn<any, AsyncValidationResult<ValidationError.WithFieldTree>>): void;
-    addMetadataRule<T>(key: MetadataKey<unknown, T, any>, logic: LogicFn<any, T>): void;
-    getChild(key: PropertyKey): LogicNodeBuilder;
-    hasLogic(builder: AbstractLogicNodeBuilder): boolean;
-    /**
-     * Merges logic from another `LogicNodeBuilder` into this one.
-     * If a `predicate` is provided, all logic from the `other` builder will only apply
-     * when the predicate evaluates to true.
-     * @param other The `LogicNodeBuilder` to merge in.
-     * @param predicate An optional predicate to gate the merged logic.
-     */
-    mergeIn(other: LogicNodeBuilder, predicate?: Predicate): void;
-    /**
-     * Gets the current `NonMergeableLogicNodeBuilder` for adding rules directly to this
-     * `LogicNodeBuilder`. If no current builder exists, a new one is created.
-     * The current builder is cleared whenever `mergeIn` is called to preserve the order
-     * of rules when merging separate builder trees.
-     * @returns The current `NonMergeableLogicNodeBuilder`.
-     */
-    private getCurrent;
-    /**
-     * Creates a new root `LogicNodeBuilder`.
-     * @returns A new instance of `LogicNodeBuilder`.
-     */
-    static newRoot(): LogicNodeBuilder;
-}
-/**
- * Represents a node in the logic tree, containing all logic applicable
- * to a specific field or path in the form structure.
- * LogicNodes are 1:1 with nodes in the Field tree.
- */
-interface LogicNode {
-    /** The collection of logic rules (hidden, disabled, errors, etc.) for this node. */
-    readonly logic: LogicContainer;
-    /**
-     * Retrieves the `LogicNode` for a child identified by the given property key.
-     * @param key The property key of the child.
-     * @returns The `LogicNode` for the specified child.
-     */
-    getChild(key: PropertyKey): LogicNode;
-    /**
-     * Checks whether the logic from a particular `AbstractLogicNodeBuilder` has been merged into this
-     * node.
-     * @param builder The builder to check for.
-     * @returns True if the builder has been merged, false otherwise.
-     */
-    hasLogic(builder: AbstractLogicNodeBuilder): boolean;
-}
-
-/**
- * Implements the `Schema` concept.
- */
-declare class SchemaImpl {
-    private schemaFn;
-    constructor(schemaFn: SchemaFn<unknown>);
-    /**
-     * Compiles this schema within the current root compilation context. If the schema was previously
-     * compiled within this context, we reuse the cached FieldPathNode, otherwise we create a new one
-     * and cache it in the compilation context.
-     */
-    compile(): FieldPathNode;
-    /**
-     * Creates a SchemaImpl from the given SchemaOrSchemaFn.
-     */
-    static create(schema: SchemaImpl | SchemaOrSchemaFn<any>): SchemaImpl;
-    /**
-     * Compiles the given schema in a fresh compilation context. This clears the cached results of any
-     * previous compilations.
-     */
-    static rootCompile(schema: SchemaImpl | SchemaOrSchemaFn<any> | undefined): FieldPathNode;
-}
-
-/**
- * A path in the schema on which logic is stored so that it can be added to the corresponding field
- * when the field is created.
- */
-declare class FieldPathNode {
-    /** The property keys used to navigate from the root path to this path. */
-    readonly keys: PropertyKey[];
-    /** The parent of this path node. */
-    private readonly parent;
-    /** The key of this node in its parent. */
-    private readonly keyInParent;
-    /** The root path node from which this path node is descended. */
-    readonly root: FieldPathNode;
-    /**
-     * A map containing all child path nodes that have been created on this path.
-     * Child path nodes are created automatically on first access if they do not exist already.
-     */
-    private readonly children;
-    /**
-     * A proxy that wraps the path node, allowing navigation to its child paths via property access.
-     */
-    readonly fieldPathProxy: SchemaPath<any>;
-    /**
-     * For a root path node this will contain the root logic builder. For non-root nodes,
-     * they determine their logic builder from their parent so this is undefined.
-     */
-    private readonly logicBuilder;
-    protected constructor(
-    /** The property keys used to navigate from the root path to this path. */
-    keys: PropertyKey[], root: FieldPathNode | undefined, 
-    /** The parent of this path node. */
-    parent: FieldPathNode | undefined, 
-    /** The key of this node in its parent. */
-    keyInParent: PropertyKey | undefined);
-    /** The logic builder used to accumulate logic on this path node. */
-    get builder(): LogicNodeBuilder;
-    /**
-     * Gets the path node for the given child property key.
-     * Child paths are created automatically on first access if they do not exist already.
-     */
-    getChild(key: PropertyKey): FieldPathNode;
-    /**
-     * Merges in logic from another schema to this one.
-     * @param other The other schema to merge in the logic from
-     * @param predicate A predicate indicating when the merged in logic should be active.
-     */
-    mergeIn(other: SchemaImpl, predicate?: Predicate): void;
-    /** Extracts the underlying path node from the given path proxy. */
-    static unwrapFieldPath(formPath: SchemaPath<unknown, SchemaPathRules>): FieldPathNode;
-    /** Creates a new root path node to be passed in to a schema function. */
-    static newRoot(): FieldPathNode;
-}
-
-/**
- * Tracks custom metadata associated with a `FieldNode`.
- */
-declare class FieldMetadataState {
-    private readonly node;
-    /** A map of all `MetadataKey` that have been defined for this field. */
-    private readonly metadata;
-    constructor(node: FieldNode);
-    /** Gets the value of an `MetadataKey` for the field. */
-    get<T>(key: MetadataKey<T, unknown, unknown>): T | undefined;
-    /** Checks whether the current metadata state has the given metadata key. */
-    has(key: MetadataKey<any, any, any>): boolean;
-}
-
-/**
- * The non-validation and non-submit state associated with a `FieldNode`, such as touched and dirty
- * status, as well as derived logical state.
- */
-declare class FieldNodeState {
-    private readonly node;
-    /**
-     * Indicates whether this field has been touched directly by the user (as opposed to indirectly by
-     * touching a child field).
-     *
-     * A field is considered directly touched when a user stops editing it for the first time (i.e. on blur)
-     */
-    private readonly selfTouched;
-    /**
-     * Indicates whether this field has been dirtied directly by the user (as opposed to indirectly by
-     * dirtying a child field).
-     *
-     * A field is considered directly dirtied if a user changed the value of the field at least once.
-     */
-    private readonly selfDirty;
-    /**
-     * Marks this specific field as touched.
-     */
-    markAsTouched(): void;
-    /**
-     * Marks this specific field as dirty.
-     */
-    markAsDirty(): void;
-    /**
-     * Marks this specific field as not dirty.
-     */
-    markAsPristine(): void;
-    /**
-     * Marks this specific field as not touched.
-     */
-    markAsUntouched(): void;
-    /** The {@link FormField} directives that bind this field to a UI control. */
-    readonly formFieldBindings: i0.WritableSignal<readonly FormField<unknown>[]>;
-    constructor(node: FieldNode);
-    /**
-     * Whether this field is considered dirty.
-     *
-     * A field is considered dirty if one of the following is true:
-     *  - It was directly dirtied and is interactive
-     *  - One of its children is considered dirty
-     */
-    readonly dirty: Signal<boolean>;
-    /**
-     * Whether this field is considered touched.
-     *
-     * A field is considered touched if one of the following is true:
-     *  - It was directly touched and is interactive
-     *  - One of its children is considered touched
-     */
-    readonly touched: Signal<boolean>;
-    /**
-     * The reasons for this field's disablement. This includes disabled reasons for any parent field
-     * that may have been disabled, indirectly causing this field to be disabled as well.
-     * The `field` property of the `DisabledReason` can be used to determine which field ultimately
-     * caused the disablement.
-     */
-    readonly disabledReasons: Signal<readonly DisabledReason[]>;
-    /**
-     * Whether this field is considered disabled.
-     *
-     * A field is considered disabled if one of the following is true:
-     * - The schema contains logic that directly disabled it
-     * - Its parent field is considered disabled
-     */
-    readonly disabled: Signal<boolean>;
-    /**
-     * Whether this field is considered readonly.
-     *
-     * A field is considered readonly if one of the following is true:
-     * - The schema contains logic that directly made it readonly
-     * - Its parent field is considered readonly
-     */
-    readonly readonly: Signal<boolean>;
-    /**
-     * Whether this field is considered hidden.
-     *
-     * A field is considered hidden if one of the following is true:
-     * - The schema contains logic that directly hides it
-     * - Its parent field is considered hidden
-     */
-    readonly hidden: Signal<boolean>;
-    readonly name: Signal<string>;
-    /**
-     * An optional {@link Debouncer} factory for this field.
-     */
-    readonly debouncer: Signal<((signal: AbortSignal) => Promise<void> | void) | undefined>;
-    /** Whether this field is considered non-interactive.
-     *
-     * A field is considered non-interactive if one of the following is true:
-     * - It is hidden
-     * - It is disabled
-     * - It is readonly
-     */
-    private readonly isNonInteractive;
-}
-
-/**
- * State of a `FieldNode` that's associated with form submission.
- */
-declare class FieldSubmitState {
-    private readonly node;
-    /**
-     * Whether this field was directly submitted (as opposed to indirectly by a parent field being submitted)
-     * and is still in the process of submitting.
-     */
-    readonly selfSubmitting: WritableSignal<boolean>;
-    /** Submission errors that are associated with this field. */
-    readonly submissionErrors: WritableSignal<readonly ValidationError.WithFieldTree[]>;
-    constructor(node: FieldNode);
-    /**
-     * Whether this form is currently in the process of being submitted.
-     * Either because the field was submitted directly, or because a parent field was submitted.
-     */
-    readonly submitting: Signal<boolean>;
-}
-
-interface ValidationState {
-    /**
-     * The full set of synchronous tree errors visible to this field. This includes ones that are
-     * targeted at a descendant field rather than at this field.
-     */
-    rawSyncTreeErrors: Signal<ValidationError.WithFieldTree[]>;
-    /**
-     * The full set of synchronous errors for this field, including synchronous tree errors and submission
-     * errors. Submission errors are considered "synchronous" because they are imperatively added. From
-     * the perspective of the field state they are either there or not, they are never in a pending
-     * state.
-     */
-    syncErrors: Signal<ValidationError.WithFieldTree[]>;
-    /**
-     * Whether the field is considered valid according solely to its synchronous validators.
-     * Errors resulting from a previous submit attempt are also considered for this state.
-     */
-    syncValid: Signal<boolean>;
-    /**
-     * The full set of asynchronous tree errors visible to this field. This includes ones that are
-     * targeted at a descendant field rather than at this field, as well as sentinel 'pending' values
-     * indicating that the validator is still running and an error could still occur.
-     */
-    rawAsyncErrors: Signal<(ValidationError.WithFieldTree | 'pending')[]>;
-    /**
-     * The asynchronous tree errors visible to this field that are specifically targeted at this field
-     * rather than a descendant. This also includes all 'pending' sentinel values, since those could
-     * theoretically result in errors for this field.
-     */
-    asyncErrors: Signal<(ValidationError.WithFieldTree | 'pending')[]>;
-    /**
-     * The combined set of all errors that currently apply to this field.
-     */
-    errors: Signal<ValidationError.WithFieldTree[]>;
-    parseErrors: Signal<ValidationError.WithFormField[]>;
-    /**
-     * The combined set of all errors that currently apply to this field and its descendants.
-     */
-    errorSummary: Signal<ValidationError.WithFieldTree[]>;
-    /**
-     * Whether this field has any asynchronous validators still pending.
-     */
-    pending: Signal<boolean>;
-    /**
-     * The validation status of the field.
-     * - The status is 'valid' if neither the field nor any of its children has any errors or pending
-     *   validators.
-     * - The status is 'invalid' if the field or any of its children has an error
-     *   (regardless of pending validators)
-     * - The status is 'unknown' if neither the field nor any of its children has any errors,
-     *   but the field or any of its children does have a pending validator.
-     *
-     * A field is considered valid if *all* of the following are true:
-     *  - It has no errors or pending validators
-     *  - All of its children are considered valid
-     * A field is considered invalid if *any* of the following are true:
-     *  - It has an error
-     *  - Any of its children is considered invalid
-     * A field is considered to have unknown validity status if it is not valid or invalid.
-     */
-    status: Signal<'valid' | 'invalid' | 'unknown'>;
-    /**
-     * Whether the field is considered valid.
-     *
-     * A field is considered valid if *all* of the following are true:
-     *  - It has no errors or pending validators
-     *  - All of its children are considered valid
-     *
-     * Note: `!valid()` is *not* the same as `invalid()`. Both `valid()` and `invalid()` can be false
-     * if there are currently no errors, but validators are still pending.
-     */
-    valid: Signal<boolean>;
-    /**
-     * Whether the field is considered invalid.
-     *
-     * A field is considered invalid if *any* of the following are true:
-     *  - It has an error
-     *  - Any of its children is considered invalid
-     *
-     * Note: `!invalid()` is *not* the same as `valid()`. Both `valid()` and `invalid()` can be false
-     * if there are currently no errors, but validators are still pending.
-     */
-    invalid: Signal<boolean>;
-    /**
-     * Indicates whether validation should be skipped for this field because it is hidden, disabled,
-     * or readonly.
-     */
-    shouldSkipValidation: Signal<boolean>;
-}
-
-/**
- * Internal node in the form tree for a given field.
- *
- * Field nodes have several responsibilities:
- *  - They track instance state for the particular field (touched)
- *  - They compute signals for derived state (valid, disabled, etc) based on their associated
- *    `LogicNode`
- *  - They act as the public API for the field (they implement the `FieldState` interface)
- *  - They implement navigation of the form tree via `.parent` and `.getChild()`.
- *
- * This class is largely a wrapper that aggregates several smaller pieces that each manage a subset of
- * the responsibilities.
- */
-declare class FieldNode implements FieldState<unknown> {
-    readonly structure: FieldNodeStructure;
-    readonly validationState: ValidationState;
-    readonly metadataState: FieldMetadataState;
-    readonly nodeState: FieldNodeState;
-    readonly submitState: FieldSubmitState;
-    readonly fieldAdapter: FieldAdapter;
-    private _context;
-    get context(): FieldContext<unknown>;
-    /**
-     * Proxy to this node which allows navigation of the form graph below it.
-     */
-    readonly fieldProxy: FieldTree<any>;
-    private readonly pathNode;
-    constructor(options: FieldNodeOptions);
-    focusBoundControl(options?: FocusOptions): void;
-    /**
-     * Gets the Field directive binding that should be focused when the developer calls
-     * `focusBoundControl` on this node.
-     *
-     * This will prioritize focusable bindings to this node, and if multiple exist, it will return
-     * the first one in the DOM. If no focusable bindings exist on this node, it will return the
-     * first focusable binding in the DOM for any descendant node of this one.
-     */
-    private getBindingForFocus;
-    /**
-     * The `AbortController` for the currently debounced sync, or `undefined` if there is none.
-     *
-     * This is used to cancel a pending debounced sync when {@link setControlValue} is called again
-     * before the pending debounced sync resolves. It will also cancel any pending debounced sync
-     * automatically when recomputed due to `value` being set directly from others sources.
-     */
-    private readonly pendingSync;
-    get logicNode(): LogicNode;
-    get value(): WritableSignal<unknown>;
-    private _controlValue;
-    get controlValue(): Signal<unknown>;
-    get keyInParent(): Signal<string | number>;
-    get errors(): Signal<ValidationError.WithFieldTree[]>;
-    get parseErrors(): Signal<ValidationError.WithFormField[]>;
-    get errorSummary(): Signal<ValidationError.WithFieldTree[]>;
-    get pending(): Signal<boolean>;
-    get valid(): Signal<boolean>;
-    get invalid(): Signal<boolean>;
-    get dirty(): Signal<boolean>;
-    get touched(): Signal<boolean>;
-    get disabled(): Signal<boolean>;
-    get disabledReasons(): Signal<readonly DisabledReason[]>;
-    get hidden(): Signal<boolean>;
-    get readonly(): Signal<boolean>;
-    get formFieldBindings(): Signal<readonly FormField<unknown>[]>;
-    get submitting(): Signal<boolean>;
-    get name(): Signal<string>;
-    get max(): Signal<number | undefined> | undefined;
-    get maxLength(): Signal<number | undefined> | undefined;
-    get min(): Signal<number | undefined> | undefined;
-    get minLength(): Signal<number | undefined> | undefined;
-    get pattern(): Signal<readonly RegExp[]>;
-    get required(): Signal<boolean>;
-    metadata<M>(key: MetadataKey<M, any, any>): M | undefined;
-    hasMetadata(key: MetadataKey<any, any, any>): boolean;
-    /**
-     * Marks this specific field as touched.
-     */
-    markAsTouched(): void;
-    /**
-     * Marks this specific field as dirty.
-     */
-    markAsDirty(): void;
-    /**
-     * Resets the {@link touched} and {@link dirty} state of the field and its descendants.
-     *
-     * Note this does not change the data model, which can be reset directly if desired.
-     *
-     * @param value Optional value to set to the form. If not passed, the value will not be changed.
-     */
-    reset(value?: unknown): void;
-    private _reset;
-    /**
-     * Sets the control value of the field. This value may be debounced before it is synchronized with
-     * the field's {@link value} signal, depending on the debounce configuration.
-     */
-    setControlValue(newValue: unknown): void;
-    /**
-     * Synchronizes the {@link controlValue} with the {@link value} signal immediately.
-     */
-    private sync;
-    /**
-     * If there is a pending sync, abort it and sync immediately.
-     */
-    private flushSync;
-    /**
-     * Initiates a debounced {@link sync}.
-     *
-     * If a debouncer is configured, the synchronization will occur after the debouncer resolves. If
-     * no debouncer is configured, the synchronization happens immediately. If {@link setControlValue}
-     * is called again while a debounce is pending, the previous debounce operation is aborted in
-     * favor of the new one.
-     */
-    private debounceSync;
-    /**
-     * Creates a new root field node for a new form.
-     */
-    static newRoot<T>(fieldManager: FormFieldManager, value: WritableSignal<T>, pathNode: FieldPathNode, adapter: FieldAdapter): FieldNode;
-    createStructure(options: FieldNodeOptions): RootFieldNodeStructure | ChildFieldNodeStructure;
-    private newChild;
-}
-/**
- * Field node of a field that has children.
- * This simplifies and makes certain types cleaner.
- */
-interface ParentFieldNode extends FieldNode {
-    readonly value: WritableSignal<Record<string, unknown>>;
-    readonly structure: FieldNodeStructure & {
-        value: WritableSignal<Record<string, unknown>>;
-    };
-}
-
-/**
- * Key by which a parent `FieldNode` tracks its children.
- *
- * Often this is the actual property key of the child, but in the case of arrays it could be a
- * tracking key allocated for the object.
- */
-type TrackingKey = PropertyKey & {
-    __brand: 'FieldIdentity';
-};
-type ChildNodeCtor = (key: string, trackingKey: TrackingKey | undefined, isArray: boolean) => FieldNode;
-/** Structural component of a `FieldNode` which tracks its path, parent, and children. */
-declare abstract class FieldNodeStructure {
-    /**
-     * Computed map of child fields, based on the current value of this field.
-     *
-     * This structure reacts to `this.value` and produces a new `ChildrenData` when the
-     * value changes structurally (fields added/removed/moved).
-     */
-    protected abstract readonly childrenMap: Signal<ChildrenData | undefined>;
-    /** The field's value. */
-    abstract readonly value: WritableSignal<unknown>;
-    /**
-     * The key of this field in its parent field.
-     * Attempting to read this for the root field will result in an error being thrown.
-     */
-    abstract readonly keyInParent: Signal<string>;
-    /** The field manager responsible for managing this field. */
-    abstract readonly fieldManager: FormFieldManager;
-    /** The root field that this field descends from. */
-    abstract readonly root: FieldNode;
-    /** The list of property keys to follow to get from the `root` to this field. */
-    abstract readonly pathKeys: Signal<readonly string[]>;
-    /** The parent field of this field. */
-    abstract readonly parent: FieldNode | undefined;
-    readonly logic: LogicNode;
-    readonly node: FieldNode;
-    readonly createChildNode: ChildNodeCtor;
-    /** Added to array elements for tracking purposes. */
-    readonly identitySymbol: symbol;
-    /** Lazily initialized injector. Do not access directly, access via `injector` getter instead. */
-    private _injector;
-    /** Lazily initialized injector. */
-    get injector(): DestroyableInjector;
-    constructor(logic: LogicNode, node: FieldNode, createChildNode: ChildNodeCtor);
-    /** Gets the child fields of this field. */
-    children(): readonly FieldNode[];
-    /** Retrieve a child `FieldNode` of this node by property key. */
-    getChild(key: PropertyKey): FieldNode | undefined;
-    /**
-     * Perform a reduction over a field's children (if any) and return the result.
-     *
-     * Optionally, the reduction is short circuited based on the provided `shortCircuit` function.
-     */
-    reduceChildren<T>(initialValue: T, fn: (child: FieldNode, value: T) => T, shortCircuit?: (value: T) => boolean): T;
-    /** Destroys the field when it is no longer needed. */
-    destroy(): void;
-    /**
-     * Creates a keyInParent signal for a field node.
-     *
-     * For root nodes, returns ROOT_KEY_IN_PARENT which throws when accessed.
-     * For child nodes, creates a computed that tracks the field's current key in its parent,
-     * with special handling for tracked array elements.
-     *
-     * @param options The field node options
-     * @param identityInParent The tracking identity (only for tracked array children)
-     * @param initialKeyInParent The initial key in parent (only for child nodes)
-     * @returns A signal representing the field's key in its parent
-     */
-    protected createKeyInParent(options: FieldNodeOptions, identityInParent: TrackingKey | undefined, initialKeyInParent: string | undefined): Signal<string>;
-    protected createChildrenMap(): Signal<ChildrenData | undefined>;
-    /**
-     * Creates a "reader" computed for the given key.
-     *
-     * A reader is a computed signal that memoizes the access of the `FieldNode` stored at this key
-     * (or returns `undefined` if no such field exists). Accessing fields via the reader ensures that
-     * reactive consumers aren't notified unless the field at a key actually changes.
-     */
-    private createReader;
-}
-/** The structural component of a `FieldNode` that is the root of its field tree. */
-declare class RootFieldNodeStructure extends FieldNodeStructure {
-    readonly fieldManager: FormFieldManager;
-    readonly value: WritableSignal<unknown>;
-    get parent(): undefined;
-    get root(): FieldNode;
-    get pathKeys(): Signal<readonly string[]>;
-    get keyInParent(): Signal<string>;
-    protected readonly childrenMap: Signal<ChildrenData | undefined>;
-    /**
-     * Creates the structure for the root node of a field tree.
-     *
-     * @param node The full field node that this structure belongs to
-     * @param pathNode The path corresponding to this node in the schema
-     * @param logic The logic to apply to this field
-     * @param fieldManager The field manager for this field
-     * @param value The value signal for this field
-     * @param adapter Adapter that knows how to create new fields and appropriate state.
-     * @param createChildNode A factory function to create child nodes for this field.
-     */
-    constructor(
-    /** The full field node that corresponds to this structure. */
-    node: FieldNode, logic: LogicNode, fieldManager: FormFieldManager, value: WritableSignal<unknown>, createChildNode: ChildNodeCtor);
-}
-/** The structural component of a child `FieldNode` within a field tree. */
-declare class ChildFieldNodeStructure extends FieldNodeStructure {
-    readonly logic: LogicNode;
-    readonly parent: ParentFieldNode;
-    readonly root: FieldNode;
-    readonly pathKeys: Signal<readonly string[]>;
-    readonly keyInParent: Signal<string>;
-    readonly value: WritableSignal<unknown>;
-    readonly childrenMap: Signal<ChildrenData | undefined>;
-    get fieldManager(): FormFieldManager;
-    /**
-     * Creates the structure for a child field node in a field tree.
-     *
-     * @param node The full field node that this structure belongs to
-     * @param pathNode The path corresponding to this node in the schema
-     * @param logic The logic to apply to this field
-     * @param parent The parent field node for this node
-     * @param identityInParent The identity used to track this field in its parent
-     * @param initialKeyInParent The key of this field in its parent at the time of creation
-     * @param adapter Adapter that knows how to create new fields and appropriate state.
-     * @param createChildNode A factory function to create child nodes for this field.
-     */
-    constructor(node: FieldNode, logic: LogicNode, parent: ParentFieldNode, identityInParent: TrackingKey | undefined, initialKeyInParent: string, createChildNode: ChildNodeCtor);
-}
-/** Options passed when constructing a root field node. */
-interface RootFieldNodeOptions {
-    /** Kind of node, used to differentiate root node options from child node options. */
-    readonly kind: 'root';
-    /** The path node corresponding to this field in the schema. */
-    readonly pathNode: FieldPathNode;
-    /** The logic to apply to this field. */
-    readonly logic: LogicNode;
-    /** The value signal for this field. */
-    readonly value: WritableSignal<unknown>;
-    /** The field manager for this field. */
-    readonly fieldManager: FormFieldManager;
-    /** This allows for more granular field and state management, and is currently used for compat. */
-    readonly fieldAdapter: FieldAdapter;
-}
-/** Options passed when constructing a child field node. */
-interface ChildFieldNodeOptions {
-    /** Kind of node, used to differentiate root node options from child node options. */
-    readonly kind: 'child';
-    /** The parent field node of this field. */
-    readonly parent: ParentFieldNode;
-    /** The path node corresponding to this field in the schema. */
-    readonly pathNode: FieldPathNode;
-    /** The logic to apply to this field. */
-    readonly logic: LogicNode;
-    /** The key of this field in its parent at the time of creation. */
-    readonly initialKeyInParent: string;
-    /** The identity used to track this field in its parent. */
-    readonly identityInParent: TrackingKey | undefined;
-    /** This allows for more granular field and state management, and is currently used for compat. */
-    readonly fieldAdapter: FieldAdapter;
-}
-/** Options passed when constructing a field node. */
-type FieldNodeOptions = RootFieldNodeOptions | ChildFieldNodeOptions;
-/**
- * Derived data regarding child fields for a specific parent field.
- */
-interface ChildrenData {
-    /**
-     * Tracks `ChildData` for each property key within the parent.
-     */
-    readonly byPropertyKey: ReadonlyMap<string, ChildData>;
-    /**
-     * Tracks the instance of child `FieldNode`s by their tracking key, which is always 1:1 with the
-     * fields, even if they move around in the parent.
-     */
-    readonly byTrackingKey?: ReadonlyMap<TrackingKey, FieldNode>;
-}
-/**
- * Data for a specific child within a parent.
- */
-interface ChildData {
-    /**
-     * A computed signal to access the `FieldNode` currently stored at a specific key.
-     *
-     * Because this is a computed, it only updates whenever the `FieldNode` at that key changes.
-     * Because `ChildData` is always associated with a specific key via `ChildrenData.byPropertyKey`,
-     * this computed gives a stable way to watch the field stored for a given property and only
-     * receives notifications when that field changes.
-     */
-    readonly reader: Signal<FieldNode | undefined>;
-    /**
-     * The child `FieldNode` currently stored at this key.
-     */
-    node: FieldNode;
-}
-
 /**
- * Manages the collection of fields associated with a given `form`.
+ * Options that can be specified when submitting a form.
  *
- * Fields are created implicitly, through reactivity, and may create "owned" entities like effects
- * or resources. When a field is no longer connected to the form, these owned entities should be
- * destroyed, which is the job of the `FormFieldManager`.
- */
-declare class FormFieldManager {
-    readonly injector: Injector;
-    readonly rootName: string;
-    constructor(injector: Injector, rootName: string | undefined);
-    /**
-     * Contains all child field structures that have been created as part of the current form.
-     * New child structures are automatically added when they are created.
-     * Structures are destroyed and removed when they are no longer reachable from the root.
-     */
-    readonly structures: Set<FieldNodeStructure>;
-    /**
-     * Creates an effect that runs when the form's structure changes and checks for structures that
-     * have become unreachable to clean up.
-     *
-     * For example, consider a form wrapped around the following model: `signal([0, 1, 2])`.
-     * This form would have 4 nodes as part of its structure tree.
-     * One structure for the root array, and one structure for each element of the array.
-     * Now imagine the data is updated: `model.set([0])`. In this case the structure for the first
-     * element can still be reached from the root, but the structures for the second and third
-     * elements are now orphaned and not connected to the root. Thus they will be destroyed.
-     *
-     * @param root The root field structure.
-     */
-    createFieldManagementEffect(root: FieldNodeStructure): void;
-    /**
-     * Collects all structures reachable from the given structure into the given set.
-     *
-     * @param structure The root structure
-     * @param liveStructures The set of reachable structures to populate
-     */
-    private markStructuresLive;
-}
-
-/**
- * Adapter allowing customization of the creation logic for a field and its associated
- * structure and state.
+ * @experimental 21.2.0
  */
-interface FieldAdapter {
-    /**
-     * Creates a node structure.
-     * @param node
-     * @param options
-     */
-    createStructure(node: FieldNode, options: FieldNodeOptions): FieldNodeStructure;
-    /**
-     * Creates node validation state
-     * @param param
-     * @param options
-     */
-    createValidationState(param: FieldNode, options: FieldNodeOptions): ValidationState;
-    /**
-     * Creates node state.
-     * @param param
-     * @param options
-     */
-    createNodeState(param: FieldNode, options: FieldNodeOptions): FieldNodeState;
-    /**
-     * Creates a custom child node.
-     * @param options
-     */
-    newChild(options: ChildFieldNodeOptions): FieldNode;
+interface FormSubmitOptions<TModel> {
+    /** Function to run when submitting the form data (when form is valid). */
+    action: (form: FieldTree<TModel>) => Promise<TreeValidationResult>;
+    /** Function to run when attempting to submit the form data but validation is failing. */
+    onInvalid?: (form: FieldTree<TModel>) => void;
     /**
-     * Creates a custom root node.
-     * @param fieldManager
-     * @param model
-     * @param pathNode
-     * @param adapter
+     * Whether to ignore any of the validators when submitting:
+     * - 'pending': Will submit if there are no invalid validators, pending validators do not block submission (default)
+     * - 'none': Will not submit unless all validators are passing, pending validators block submission
+     * - 'ignore': Will always submit regardless of invalid or pending validators
      */
-    newRoot<TValue>(fieldManager: FormFieldManager, model: WritableSignal<TValue>, pathNode: FieldPathNode, adapter: FieldAdapter): FieldNode;
+    ignoreValidators?: 'pending' | 'none' | 'all';
 }
-
 /**
  * Options that may be specified when creating a form.
  *
  * @category structure
  * @experimental 21.0.0
  */
-interface FormOptions {
+interface FormOptions<TModel> {
     /**
      * The injector to use for dependency injection. If this is not provided, the injector for the
      * current [injection context](guide/di/dependency-injection-context), will be used.
      */
     injector?: Injector;
+    /** The name of the root form, used in generating name attributes for the fields. */
     name?: string;
-    /**
-     * Adapter allows managing fields in a more flexible way.
-     * Currently this is used to support interop with reactive forms.
-     */
-    adapter?: FieldAdapter;
+    /** Options that define how to handle form submission. */
+    submission?: FormSubmitOptions<TModel>;
 }
 /**
  * Creates a form wrapped around the given model data. A form is represented as simply a `FieldTree`
@@ -2235,7 +1446,7 @@ declare function form<TModel>(model: WritableSignal<TModel>): FieldTree<TModel>;
  * @category structure
  * @experimental 21.0.0
  */
-declare function form<TModel>(model: WritableSignal<TModel>, schemaOrOptions: SchemaOrSchemaFn<TModel> | FormOptions): FieldTree<TModel>;
+declare function form<TModel>(model: WritableSignal<TModel>, schemaOrOptions: SchemaOrSchemaFn<TModel> | FormOptions<TModel>): FieldTree<TModel>;
 /**
  * Creates a form wrapped around the given model data. A form is represented as simply a `FieldTree`
  * of the model data.
@@ -2279,7 +1490,7 @@ declare function form<TModel>(model: WritableSignal<TModel>, schemaOrOptions: Sc
  * @category structure
  * @experimental 21.0.0
  */
-declare function form<TModel>(model: WritableSignal<TModel>, schema: SchemaOrSchemaFn<TModel>, options: FormOptions): FieldTree<TModel>;
+declare function form<TModel>(model: WritableSignal<TModel>, schema: SchemaOrSchemaFn<TModel>, options: FormOptions<TModel>): FieldTree<TModel>;
 /**
  * Applies a schema to each item of an array.
  *
@@ -2386,21 +1597,24 @@ declare function applyWhenValue<TValue>(path: SchemaPath<TValue>, predicate: (va
  * }
  *
  * const registrationForm = form(signal({username: 'god', password: ''}));
- * submit(registrationForm, async (f) => {
- *   return registerNewUser(registrationForm);
+ * submit(registrationForm, {
+ *   action: async (f) => {
+ *     return registerNewUser(registrationForm);
+ *   }
  * });
  * registrationForm.username().errors(); // [{kind: 'server', message: 'Username already taken'}]
  * ```
  *
  * @param form The field to submit.
- * @param action An asynchronous action used to submit the field. The action may return submission
- * errors.
+ * @param options Options for the submission.
+ * @returns Whether the submission was successful.
  * @template TModel The data type of the field being submitted.
  *
  * @category submission
  * @experimental 21.0.0
  */
-declare function submit<TModel>(form: FieldTree<TModel>, action: (form: FieldTree<TModel>) => Promise<TreeValidationResult>): Promise<void>;
+declare function submit<TModel>(form: FieldTree<TModel>, options?: FormSubmitOptions<TModel>): Promise<boolean>;
+declare function submit<TModel>(form: FieldTree<TModel>, action: FormSubmitOptions<TModel>['action']): Promise<boolean>;
 /**
  * Creates a `Schema` that adds logic rules to a form.
  * @param fn A **non-reactive** function that sets up reactive logic rules for the form.
@@ -2412,5 +1626,5 @@ declare function submit<TModel>(form: FieldTree<TModel>, action: (form: FieldTre
  */
 declare function schema<TValue>(fn: SchemaFn<TValue>): Schema<TValue>;
 
-export { EmailValidationError, FORM_FIELD, FormField, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MetadataKey, MetadataReducer, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PathKind, PatternValidationError, REQUIRED, RequiredValidationError, SchemaPathRules, StandardSchemaValidationError, ValidationError, apply, applyEach, applyWhen, applyWhenValue, createManagedMetadataKey, createMetadataKey, emailError, form, maxError, maxLengthError, metadata, minError, minLengthError, patternError, provideSignalFormsConfig, requiredError, schema, standardSchemaError, submit };
-export type { AsyncValidationResult, ChildFieldContext, CompatFieldState, CompatSchemaPath, Debouncer, DisabledReason, FieldContext, FieldState, FieldTree, FieldValidator, FormFieldBindingOptions, FormOptions, ItemFieldContext, ItemType, LogicFn, MaybeFieldTree, MaybeSchemaPathTree, MetadataSetterType, OneOrMany, ReadonlyArrayLike, RootFieldContext, Schema, SchemaFn, SchemaOrSchemaFn, SchemaPath, SchemaPathTree, SignalFormsConfig, Subfields, TreeValidationResult, TreeValidator, ValidationResult, ValidationSuccess, Validator, WithField, WithFieldTree, WithOptionalField, WithOptionalFieldTree, WithoutField, WithoutFieldTree };
+export { BaseNgValidationError, EmailValidationError, FORM_FIELD, FormField, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MetadataKey, MetadataReducer, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PathKind, PatternValidationError, REQUIRED, RequiredValidationError, SchemaPathRules, StandardSchemaValidationError, ValidationError, apply, applyEach, applyWhen, applyWhenValue, createManagedMetadataKey, createMetadataKey, emailError, form, maxError, maxLengthError, metadata, minError, minLengthError, patternError, provideSignalFormsConfig, requiredError, schema, standardSchemaError, submit, validateStandardSchema, ɵNgFieldDirective };
+export type { AsyncValidationResult, ChildFieldContext, CompatFieldState, CompatSchemaPath, Debouncer, DisabledReason, FieldContext, FieldState, FieldTree, FieldValidator, FormFieldBindingOptions, FormOptions, FormSubmitOptions, IgnoreUnknownProperties, ItemFieldContext, ItemType, LogicFn, MaybeFieldTree, MaybeSchemaPathTree, MetadataSetterType, OneOrMany, ReadonlyArrayLike, RemoveStringIndexUnknownKey, RootFieldContext, Schema, SchemaFn, SchemaOrSchemaFn, SchemaPath, SchemaPathTree, SignalFormsConfig, Subfields, TreeValidationResult, TreeValidator, ValidationErrorOptions, ValidationResult, ValidationSuccess, Validator, WithField, WithFieldTree, WithOptionalField, WithOptionalFieldTree, WithoutField, WithoutFieldTree };