@angular/forms 21.0.4 → 21.1.0-next.1

package/types/_structure-chunk.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Angular v21.0.4
+ * @license Angular v21.1.0-next.1
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
 import * as i0 from '@angular/core';
-import { InjectionToken, ɵControl as _Control, Injector, ɵCONTROL as _CONTROL, ɵɵcontrolCreate as __controlCreate, ɵcontrolUpdate as _controlUpdate, Signal, ɵFieldState as _FieldState, Provider, WritableSignal, DestroyableInjector } from '@angular/core';
+import { InjectionToken, ɵControl as _Control, ɵCONTROL as _CONTROL, ɵɵcontrolCreate as __controlCreate, ɵcontrolUpdate as _controlUpdate, ɵInteropControl as _InteropControl, ɵFieldState as _FieldState, Signal, Provider, WritableSignal, DestroyableInjector, Injector } from '@angular/core';
 import * as _angular_forms from '@angular/forms';
 import { NgControl, AbstractControl, ValidationErrors, FormControlStatus, ControlValueAccessor, ValidatorFn } from '@angular/forms';
 import { StandardSchemaV1 } from '@standard-schema/spec';
@@ -69,1043 +69,1006 @@ declare const FIELD: InjectionToken<Field<unknown>>;
  * @experimental 21.0.0
  */
 declare class Field<T> implements _Control<T> {
-    readonly element: HTMLElement;
-    readonly injector: Injector;
+    private readonly injector;
+    private config;
+    readonly classes: (readonly [string, i0.Signal<boolean>])[];
     readonly field: i0.InputSignal<FieldTree<T>>;
     readonly state: i0.Signal<[T] extends [_angular_forms.AbstractControl<any, any, any>] ? CompatFieldState<T, string | number> : FieldState<T, string | number>>;
     readonly [_CONTROL]: {
         readonly create: typeof __controlCreate;
         readonly update: typeof _controlUpdate;
     };
-    private config;
     /** Any `ControlValueAccessor` instances provided on the host element. */
     private readonly controlValueAccessors;
     /** A lazily instantiated fake `NgControl`. */
     private interopNgControl;
+    /** A `ControlValueAccessor`, if configured, for the host component. */
+    get ɵinteropControl(): _InteropControl | undefined;
     /** Lazily instantiates a fake `NgControl` for this field. */
     protected getOrCreateNgControl(): InteropNgControl;
+    ɵregister(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<Field<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<Field<any>, "[field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
- * Sets a value for the {@link MetadataKey} for this field.
- *
- * This value is combined via a reduce operation defined by the particular key,
- * since multiple rules in the schema might set values for it.
- *
- * @param path The target path to set the metadata for.
- * @param key The metadata key
- * @param logic A function that receives the `FieldContext` and returns a value for the metadata.
- * @template TValue The type of value stored in the field the logic is bound to.
- * @template TKey The type of metadata key.
- * @template TPathKind The kind of path the logic is bound to (a root path, child path, or item of an array)
+ * Represents metadata that may be defined on a field when it is created using a `metadata` rule
+ * in the schema. A particular `MetadataKey` can only be defined on a particular field **once**.
  *
  * @category logic
  * @experimental 21.0.0
  */
-declare function metadata<TValue, TKey extends MetadataKey<any, any, any>, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, key: TKey, logic: NoInfer<LogicFn<TValue, MetadataSetterType<TKey>, TPathKind>>): TKey;
+declare class MetadataKey<TValue> {
+    private brand;
+    /** Use {@link createMetadataKey}. */
+    private constructor();
+}
 /**
- * A reducer that determines the accumulated value for a metadata key by reducing the individual
- * values contributed from `metadata()` rules.
+ * Creates a {@link MetadataKey}.
  *
- * @template TAcc The accumulated type of the reduce operation.
- * @template TItem The type of the individual items that are reduced over.
- * @experimental 21.0.2
+ * @experimental 21.0.0
  */
-interface MetadataReducer<TAcc, TItem> {
-    /** The reduce function. */
-    reduce: (acc: TAcc, item: TItem) => TAcc;
-    /** Gets the initial accumulated value. */
-    getInitial: () => TAcc;
-}
-declare const MetadataReducer: {
-    /** Creates a reducer that accumulates a list of its individual item values. */
-    readonly list: <TItem>() => MetadataReducer<TItem[], TItem | undefined>;
-    /** Creates a reducer that accumulates the min of its individual item values. */
-    readonly min: () => MetadataReducer<number | undefined, number | undefined>;
-    /** Creates a reducer that accumulates a the max of its individual item values. */
-    readonly max: () => MetadataReducer<number | undefined, number | undefined>;
-    /** Creates a reducer that logically or's its accumulated value with each individual item value. */
-    readonly or: () => MetadataReducer<boolean, boolean>;
-    /** Creates a reducer that logically and's its accumulated value with each individual item value. */
-    readonly and: () => MetadataReducer<boolean, boolean>;
-    /** Creates a reducer that always takes the next individual item value as the accumulated value. */
-    readonly override: typeof override;
-};
-declare function override<T>(): MetadataReducer<T | undefined, T>;
-declare function override<T>(getInitial: () => T): MetadataReducer<T, T>;
+declare function createMetadataKey<TValue>(): MetadataKey<TValue>;
 /**
  * Represents metadata that is aggregated from multiple parts according to the key's reducer
  * function. A value can be contributed to the aggregated value for a field using an
- * `metadata` rule in the schema. There may be multiple rules in a schema that contribute
- * values to the same `MetadataKey` of the same field.
- *
- * @template TRead The type read from the `FieldState` for this key
- * @template TWrite The type written to this key using the `metadata()` rule
- * @template TAcc The type of the reducer's accumulated value.
+ * `aggregateMetadata` rule in the schema. There may be multiple rules in a schema that contribute
+ * values to the same `AggregateMetadataKey` of the same field.
  *
  * @experimental 21.0.0
  */
-declare class MetadataKey<TRead, TWrite, TAcc> {
-    readonly reducer: MetadataReducer<TAcc, TWrite>;
-    readonly create: ((s: Signal<TAcc>) => TRead) | undefined;
+declare class AggregateMetadataKey<TAcc, TItem> {
+    readonly reduce: (acc: TAcc, item: TItem) => TAcc;
+    readonly getInitial: () => TAcc;
     private brand;
     /** Use {@link reducedMetadataKey}. */
-    protected constructor(reducer: MetadataReducer<TAcc, TWrite>, create: ((s: Signal<TAcc>) => TRead) | undefined);
+    private constructor();
 }
 /**
- * Extracts the the type that can be set into the given metadata key type using the `metadata()` rule.
- *
- * @template TKey The `MetadataKey` type
+ * Creates an {@link AggregateMetadataKey} that reduces its individual values into an accumulated
+ * value using the given `reduce` and `getInitial` functions.
+ * @param reduce The reducer function.
+ * @param getInitial A function that gets the initial value for the reduce operation.
  *
  * @experimental 21.0.0
  */
-type MetadataSetterType<TKey> = TKey extends MetadataKey<any, infer TWrite, any> ? TWrite : never;
+declare function reducedMetadataKey<TAcc, TItem>(reduce: (acc: TAcc, item: TItem) => TAcc, getInitial: NoInfer<() => TAcc>): AggregateMetadataKey<TAcc, TItem>;
 /**
- * Creates a metadata key used to contain a computed value.
- * The last value set on a given field tree node overrides any previously set values.
- *
- * @template TWrite The type written to this key using the `metadata()` rule
+ * Creates an {@link AggregateMetadataKey} that reduces its individual values into a list.
  *
  * @experimental 21.0.0
  */
-declare function createMetadataKey<TWrite>(): MetadataKey<Signal<TWrite | undefined>, TWrite, TWrite | undefined>;
+declare function listMetadataKey<TItem>(): AggregateMetadataKey<TItem[], TItem | undefined>;
 /**
- * Creates a metadata key used to contain a computed value.
- *
- * @param reducer The reducer used to combine individually set values into the final computed value.
- * @template TWrite The type written to this key using the `metadata()` rule
- * @template TAcc The type of the reducer's accumulated value.
+ * Creates {@link AggregateMetadataKey} that reduces its individual values by taking their min.
  *
  * @experimental 21.0.0
  */
-declare function createMetadataKey<TWrite, TAcc>(reducer: MetadataReducer<TAcc, TWrite>): MetadataKey<Signal<TAcc>, TWrite, TAcc>;
+declare function minMetadataKey(): AggregateMetadataKey<number | undefined, number | undefined>;
 /**
- * Creates a metadata key that exposes a managed value based on the accumulated result of the values
- * written to the key. The accumulated value takes the last value set on a given field tree node,
- * overriding any previously set values.
- *
- * @param create A function that receives a signal of the accumulated value and returns the managed
- *   value based on it. This function runs during the construction of the `FieldTree` node,
- *   and runs in the injection context of that node.
- * @template TRead The type read from the `FieldState` for this key
- * @template TWrite The type written to this key using the `metadata()` rule
+ * Creates {@link AggregateMetadataKey} that reduces its individual values by taking their max.
  *
  * @experimental 21.0.0
  */
-declare function createManagedMetadataKey<TRead, TWrite>(create: (s: Signal<TWrite | undefined>) => TRead): MetadataKey<TRead, TWrite, TWrite | undefined>;
+declare function maxMetadataKey(): AggregateMetadataKey<number | undefined, number | undefined>;
 /**
- * Creates a metadata key that exposes a managed value based on the accumulated result of the values
- * written to the key.
+ * Creates an {@link AggregateMetadataKey} that reduces its individual values by logically or-ing
+ * them.
  *
- * @param create A function that receives a signal of the accumulated value and returns the managed
- *   value based on it. This function runs during the construction of the `FieldTree` node,
- *   and runs in the injection context of that node.
- * @param reducer The reducer used to combine individual value written to the key,
- *   this will determine the accumulated value that the create function receives.
- * @template TRead The type read from the `FieldState` for this key
- * @template TWrite The type written to this key using the `metadata()` rule
- * @template TAcc The type of the reducer's accumulated value.
+ * @experimental 21.0.0
+ */
+declare function orMetadataKey(): AggregateMetadataKey<boolean, boolean>;
+/**
+ * Creates an {@link AggregateMetadataKey} that reduces its individual values by logically and-ing
+ * them.
  *
  * @experimental 21.0.0
  */
-declare function createManagedMetadataKey<TRead, TWrite, TAcc>(create: (s: Signal<TAcc>) => TRead, reducer: MetadataReducer<TAcc, TWrite>): MetadataKey<TRead, TWrite, TAcc>;
+declare function andMetadataKey(): AggregateMetadataKey<boolean, boolean>;
 /**
- * A {@link MetadataKey} representing whether the field is required.
+ * An {@link AggregateMetadataKey} representing whether the field is required.
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare const REQUIRED: MetadataKey<Signal<boolean>, boolean, boolean>;
+declare const REQUIRED: AggregateMetadataKey<boolean, boolean>;
 /**
- * A {@link MetadataKey} representing the min value of the field.
+ * An {@link AggregateMetadataKey} representing the min value of the field.
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare const MIN: MetadataKey<Signal<number | undefined>, number | undefined, number | undefined>;
+declare const MIN: AggregateMetadataKey<number | undefined, number | undefined>;
 /**
- * A {@link MetadataKey} representing the max value of the field.
+ * An {@link AggregateMetadataKey} representing the max value of the field.
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare const MAX: MetadataKey<Signal<number | undefined>, number | undefined, number | undefined>;
+declare const MAX: AggregateMetadataKey<number | undefined, number | undefined>;
 /**
- * A {@link MetadataKey} representing the min length of the field.
+ * An {@link AggregateMetadataKey} representing the min length of the field.
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare const MIN_LENGTH: MetadataKey<Signal<number | undefined>, number | undefined, number | undefined>;
+declare const MIN_LENGTH: AggregateMetadataKey<number | undefined, number | undefined>;
 /**
- * A {@link MetadataKey} representing the max length of the field.
+ * An {@link AggregateMetadataKey} representing the max length of the field.
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare const MAX_LENGTH: MetadataKey<Signal<number | undefined>, number | undefined, number | undefined>;
+declare const MAX_LENGTH: AggregateMetadataKey<number | undefined, number | undefined>;
 /**
- * A {@link MetadataKey} representing the patterns the field must match.
+ * An {@link AggregateMetadataKey} representing the patterns the field must match.
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare const PATTERN: MetadataKey<Signal<RegExp[]>, RegExp | undefined, RegExp[]>;
+declare const PATTERN: AggregateMetadataKey<RegExp[], RegExp | undefined>;
 
 /**
- * Symbol used to retain generic type information when it would otherwise be lost.
+ * Options used to create a `ValidationError`.
  */
-declare const ɵɵTYPE: unique symbol;
+interface ValidationErrorOptions {
+    /** Human readable error message. */
+    message?: string;
+}
 /**
- * A type that represents either a single value of type `T` or a readonly array of `T`.
- * @template T The type of the value(s).
+ * A type that requires the given type `T` to have a `field` property.
+ * @template T The type to add a `field` to.
  *
  * @experimental 21.0.0
  */
-type OneOrMany<T> = T | readonly T[];
+type WithField<T> = T & {
+    field: FieldTree<unknown>;
+};
 /**
- * The kind of `FieldPath` (`Root`, `Child` of another `FieldPath`, or `Item` in a `FieldPath` array)
+ * A type that allows the given type `T` to optionally have a `field` property.
+ * @template T The type to optionally add a `field` to.
  *
  * @experimental 21.0.0
  */
-type PathKind = PathKind.Root | PathKind.Child | PathKind.Item;
-declare namespace PathKind {
-    /**
-     * The `PathKind` for a `FieldPath` that is at the root of its field tree.
-     */
-    interface Root {
-        /**
-         * The `ɵɵTYPE` is constructed to allow the `extends` clause on `Child` and `Item` to narrow the
-         * type. Another way to think about this is, if we have a function that expects this kind of
-         * path, the `ɵɵTYPE` lists the kinds of path we are allowed to pass to it.
-         */
-        [ɵɵTYPE]: 'root' | 'child' | 'item';
-    }
-    /**
-     * The `PathKind` for a `FieldPath` that is a child of another `FieldPath`.
-     */
-    interface Child extends PathKind.Root {
-        [ɵɵTYPE]: 'child' | 'item';
-    }
-    /**
-     * The `PathKind` for a `FieldPath` that is an item in a `FieldPath` array.
-     */
-    interface Item extends PathKind.Child {
-        [ɵɵTYPE]: 'item';
-    }
-}
+type WithOptionalField<T> = Omit<T, 'field'> & {
+    field?: FieldTree<unknown>;
+};
 /**
- * A status indicating whether a field is unsubmitted, submitted, or currently submitting.
+ * A type that ensures the given type `T` does not have a `field` property.
+ * @template T The type to remove the `field` from.
  *
- * @category types
  * @experimental 21.0.0
  */
-type SubmittedStatus = 'unsubmitted' | 'submitted' | 'submitting';
+type WithoutField<T> = T & {
+    field: never;
+};
 /**
- * A reason for a field's disablement.
+ * Create a required error associated with the target field
+ * @param options The validation error options
  *
- * @category logic
  * @experimental 21.0.0
  */
-interface DisabledReason {
-    /** The field that is disabled. */
-    readonly field: FieldTree<unknown>;
-    /** A user-facing message describing the reason for the disablement. */
-    readonly message?: string;
-}
+declare function requiredError(options: WithField<ValidationErrorOptions>): RequiredValidationError;
 /**
- * The absence of an error which indicates a successful validation result.
+ * Create a required error
+ * @param options The optional validation error options
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type ValidationSuccess = null | undefined | void;
+declare function requiredError(options?: ValidationErrorOptions): WithoutField<RequiredValidationError>;
 /**
- * The result of running a tree validation function.
- *
- * The result may be one of the following:
- * 1. A {@link ValidationSuccess} to indicate no errors.
- * 2. A {@link ValidationError} without a field to indicate an error on the field being validated.
- * 3. A {@link ValidationError} with a field to indicate an error on the target field.
- * 4. A list of {@link ValidationError} with or without fields to indicate multiple errors.
- *
- * @template E the type of error (defaults to {@link ValidationError}).
+ * Create a min value error associated with the target field
+ * @param min The min value constraint
+ * @param options The validation error options
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type TreeValidationResult<E extends ValidationError.WithOptionalField = ValidationError.WithOptionalField> = ValidationSuccess | OneOrMany<E>;
+declare function minError(min: number, options: WithField<ValidationErrorOptions>): MinValidationError;
 /**
- * A validation result where all errors explicitly define their target field.
+ * Create a min value error
+ * @param min The min value constraint
+ * @param options The optional validation error options
  *
- * The result may be one of the following:
- * 1. A {@link ValidationSuccess} to indicate no errors.
- * 2. A {@link ValidationError} with a field to indicate an error on the target field.
- * 3. A list of {@link ValidationError} with fields to indicate multiple errors.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function minError(min: number, options?: ValidationErrorOptions): WithoutField<MinValidationError>;
+/**
+ * Create a max value error associated with the target field
+ * @param max The max value constraint
+ * @param options The validation error options
  *
- * @template E the type of error (defaults to {@link ValidationError}).
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function maxError(max: number, options: WithField<ValidationErrorOptions>): MaxValidationError;
+/**
+ * Create a max value error
+ * @param max The max value constraint
+ * @param options The optional validation error options
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type ValidationResult<E extends ValidationError = ValidationError> = ValidationSuccess | OneOrMany<E>;
+declare function maxError(max: number, options?: ValidationErrorOptions): WithoutField<MaxValidationError>;
 /**
- * An asynchronous validation result where all errors explicitly define their target field.
+ * Create a minLength error associated with the target field
+ * @param minLength The minLength constraint
+ * @param options The validation error options
  *
- * The result may be one of the following:
- * 1. A {@link ValidationResult} to indicate the result if resolved.
- * 5. 'pending' if the validation is not yet resolved.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function minLengthError(minLength: number, options: WithField<ValidationErrorOptions>): MinLengthValidationError;
+/**
+ * Create a minLength error
+ * @param minLength The minLength constraint
+ * @param options The optional validation error options
  *
- * @template E the type of error (defaults to {@link ValidationError}).
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function minLengthError(minLength: number, options?: ValidationErrorOptions): WithoutField<MinLengthValidationError>;
+/**
+ * Create a maxLength error associated with the target field
+ * @param maxLength The maxLength constraint
+ * @param options The validation error options
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type AsyncValidationResult<E extends ValidationError = ValidationError> = ValidationResult<E> | 'pending';
+declare function maxLengthError(maxLength: number, options: WithField<ValidationErrorOptions>): MaxLengthValidationError;
 /**
- * An object that represents a tree of fields in a form. This includes both primitive value fields
- * (e.g. fields that contain a `string` or `number`), as well as "grouping fields" that contain
- * sub-fields. `FieldTree` objects are arranged in a tree whose structure mimics the structure of the
- * underlying data. For example a `FieldTree<{x: number}>` has a property `x` which contains a
- * `FieldTree<number>`. To access the state associated with a field, call it as a function.
+ * Create a maxLength error
+ * @param maxLength The maxLength constraint
+ * @param options The optional validation error options
  *
- * @template TValue The type of the data which the field is wrapped around.
- * @template TKey The type of the property key which this field resides under in its parent.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function maxLengthError(maxLength: number, options?: ValidationErrorOptions): WithoutField<MaxLengthValidationError>;
+/**
+ * Create a pattern matching error associated with the target field
+ * @param pattern The violated pattern
+ * @param options The validation error options
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type FieldTree<TModel, TKey extends string | number = string | number> = (() => [TModel] extends [AbstractControl] ? CompatFieldState<TModel, TKey> : FieldState<TModel, TKey>) & ([TModel] extends [AbstractControl] ? object : [TModel] extends [Array<infer U>] ? ReadonlyArrayLike<MaybeFieldTree<U, number>> : TModel extends Record<string, any> ? Subfields<TModel> : object);
+declare function patternError(pattern: RegExp, options: WithField<ValidationErrorOptions>): PatternValidationError;
 /**
- * The sub-fields that a user can navigate to from a `FieldTree<TModel>`.
+ * Create a pattern matching error
+ * @param pattern The violated pattern
+ * @param options The optional validation error options
  *
- * @template TModel The type of the data which the parent field is wrapped around.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function patternError(pattern: RegExp, options?: ValidationErrorOptions): WithoutField<PatternValidationError>;
+/**
+ * Create an email format error associated with the target field
+ * @param options The validation error options
  *
+ * @category validation
  * @experimental 21.0.0
  */
-type Subfields<TModel> = {
-    readonly [K in keyof TModel as TModel[K] extends Function ? never : K]: MaybeFieldTree<TModel[K], string>;
-} & {
-    [Symbol.iterator](): Iterator<[string, MaybeFieldTree<TModel[keyof TModel], string>]>;
-};
+declare function emailError(options: WithField<ValidationErrorOptions>): EmailValidationError;
 /**
- * An iterable object with the same shape as a readonly array.
+ * Create an email format error
+ * @param options The optional validation error options
  *
- * @template T The array item type.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function emailError(options?: ValidationErrorOptions): WithoutField<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
  */
-type ReadonlyArrayLike<T> = Pick<ReadonlyArray<T>, number | 'length' | typeof Symbol.iterator>;
+declare function standardSchemaError(issue: StandardSchemaV1.Issue, options: WithField<ValidationErrorOptions>): StandardSchemaValidationError;
 /**
- * Helper type for defining `FieldTree`. Given a type `TValue` that may include `undefined`, it extracts
- * the `undefined` outside the `FieldTree` type.
+ * Create a standard schema issue error
+ * @param issue The standard schema issue
+ * @param options The optional validation error options
  *
- * For example `MaybeField<{a: number} | undefined, TKey>` would be equivalent to
- * `undefined | FieldTree<{a: number}, TKey>`.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function standardSchemaError(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions): WithoutField<StandardSchemaValidationError>;
+/**
+ * Create a custom error associated with the target field
+ * @param obj The object to create an error from
  *
- * @template TModel The type of the data which the field is wrapped around.
- * @template TKey The type of the property key which this field resides under in its parent.
+ * @category validation
+ * @experimental 21.0.0
+ */
+declare function customError<E extends Partial<ValidationError.WithField>>(obj: WithField<E>): CustomValidationError;
+/**
+ * Create a custom error
+ * @param obj The object to create an error from
  *
+ * @category validation
  * @experimental 21.0.0
  */
-type MaybeFieldTree<TModel, TKey extends string | number = string | number> = (TModel & undefined) | FieldTree<Exclude<TModel, undefined>, TKey>;
+declare function customError<E extends Partial<ValidationError.WithField>>(obj?: E): WithoutField<CustomValidationError>;
 /**
- * Contains all of the state (e.g. value, statuses, etc.) associated with a `FieldTree`, exposed as
- * signals.
+ * Common interface for all validation errors.
  *
- * @category structure
+ * This can be returned from validators.
+ *
+ * It's also used by the creation functions to create an instance
+ * (e.g. `requiredError`, `minError`, etc.).
+ *
+ * @category validation
  * @experimental 21.0.0
  */
-interface FieldState<TValue, TKey extends string | number = string | number> extends _FieldState<TValue> {
-    /**
-     * A signal indicating whether field value has been changed by user.
-     */
-    readonly dirty: Signal<boolean>;
-    /**
-     * A signal indicating whether a field is hidden.
-     *
-     * When a field is hidden it is ignored when determining the valid, touched, and dirty states.
-     *
-     * Note: This doesn't hide the field in the template, that must be done manually.
-     * ```
-     * @if (!field.hidden()) {
-     *   ...
-     * }
-     * ```
-     */
-    readonly hidden: Signal<boolean>;
-    readonly disabledReasons: Signal<readonly DisabledReason[]>;
-    readonly errors: Signal<ValidationError.WithField[]>;
-    /**
-     * A signal containing the {@link errors} of the field and its descendants.
-     */
-    readonly errorSummary: Signal<ValidationError.WithField[]>;
+interface ValidationError {
+    /** Identifies the kind of error. */
+    readonly kind: string;
+    /** Human readable error message. */
+    readonly message?: string;
+}
+declare namespace ValidationError {
     /**
-     * A signal indicating whether the field's value is currently valid.
-     *
-     * Note: `valid()` is not the same as `!invalid()`.
-     * - `valid()` is `true` when there are no validation errors *and* no pending validators.
-     * - `invalid()` is `true` when there are validation errors, regardless of pending validators.
+     * Validation error with a field.
      *
-     * Ex: consider the situation where a field has 3 validators, 2 of which have no errors and 1 of
-     * which is still pending. In this case `valid()` is `false` because of the pending validator.
-     * However `invalid()` is also `false` because there are no errors.
+     * This is returned from field state, e.g., catField.errors() would be of a list of errors with
+     * `field: catField` bound to state.
      */
-    readonly valid: Signal<boolean>;
+    interface WithField extends ValidationError {
+        /** The field associated with this error. */
+        readonly field: FieldTree<unknown>;
+    }
     /**
-     * A signal indicating whether the field's value is currently invalid.
-     *
-     * Note: `invalid()` is not the same as `!valid()`.
-     * - `invalid()` is `true` when there are validation errors, regardless of pending validators.
-     * - `valid()` is `true` when there are no validation errors *and* no pending validators.
+     * Validation error with optional field.
      *
-     * Ex: consider the situation where a field has 3 validators, 2 of which have no errors and 1 of
-     * which is still pending. In this case `invalid()` is `false` because there are no errors.
-     * However `valid()` is also `false` because of the pending validator.
-     */
-    readonly invalid: Signal<boolean>;
-    /**
-     * Whether there are any validators still pending for this field.
-     */
-    readonly pending: Signal<boolean>;
-    /**
-     * A signal indicating whether the field is currently in the process of being submitted.
-     */
-    readonly submitting: Signal<boolean>;
-    /**
-     * The property key in the parent field under which this field is stored. If the parent field is
-     * array-valued, for example, this is the index of this field in that array.
-     */
-    readonly keyInParent: Signal<TKey>;
-    /**
-     * The {@link Field} directives that bind this field to a UI control.
-     */
-    readonly fieldBindings: Signal<readonly Field<unknown>[]>;
-    /**
-     * Reads a metadata value from the field.
-     * @param key The metadata key to read.
+     * This is generally used in places where the result might have a field.
+     * e.g., as a result of a `validateTree`, or when handling form submission.
      */
-    metadata<M>(key: MetadataKey<M, any, any>): M | undefined;
+    interface WithOptionalField extends ValidationError {
+        /** The field associated with this error. */
+        readonly field?: FieldTree<unknown>;
+    }
     /**
-     * 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.
+     * Validation error with no field.
      *
-     * @param value Optional value to set to the form. If not passed, the value will not be changed.
+     * This is used to strongly enforce that fields are not allowed in validation result.
      */
-    reset(value?: TValue): void;
+    interface WithoutField extends ValidationError {
+        /** The field associated with this error. */
+        readonly field?: never;
+    }
 }
 /**
- * This is FieldState also providing access to the wrapped FormControl.
+ * A custom error that may contain additional properties
  *
- * @category interop
+ * @category validation
  * @experimental 21.0.0
  */
-type CompatFieldState<TControl extends AbstractControl, TKey extends string | number = string | number> = FieldState<TControl extends AbstractControl<unknown, infer TValue> ? TValue : never, TKey> & {
-    control: Signal<TControl>;
-};
-/**
- * Allows declaring whether the Rules are supported for a given path.
- *
- * @experimental 21.0.0
- **/
-type SchemaPathRules = SchemaPathRules.Supported | SchemaPathRules.Unsupported;
-declare namespace SchemaPathRules {
-    /**
-     * Used for paths that support settings rules.
-     */
-    type Supported = 1;
+declare class CustomValidationError implements ValidationError {
+    /** Brand the class to avoid Typescript structural matching */
+    private __brand;
     /**
-     * Used for paths that do not support settings rules, e.g., compatPath.
+     * Allow the user to attach arbitrary other properties.
      */
-    type Unsupported = 2;
+    [key: PropertyKey]: unknown;
+    /** Identifies the kind of error. */
+    readonly kind: string;
+    /** The field associated with this error. */
+    readonly field: FieldTree<unknown>;
+    /** Human readable error message. */
+    readonly message?: string;
+    constructor(options?: ValidationErrorOptions);
 }
 /**
- * An object that represents a location in the `FieldTree` tree structure and is used to bind logic to a
- * particular part of the structure prior to the creation of the form. Because the `FieldPath`
- * exists prior to the form's creation, it cannot be used to access any of the field state.
- *
- * @template TValue The type of the data which the form is wrapped around.
- * @template TPathKind The kind of path (root field, child field, or item of an array)
+ * Internal version of `NgValidationError`, we create this separately so we can change its type on
+ * the exported version to a type union of the possible sub-classes.
  *
- * @category types
  * @experimental 21.0.0
  */
-type SchemaPath<TValue, TSupportsRules extends SchemaPathRules = SchemaPathRules.Supported, TPathKind extends PathKind = PathKind.Root> = {
-    [ɵɵTYPE]: {
-        value: () => TValue;
-        supportsRules: TSupportsRules;
-        pathKind: TPathKind;
-    };
-};
+declare abstract class _NgValidationError implements ValidationError {
+    /** Brand the class to avoid Typescript structural matching */
+    private __brand;
+    /** Identifies the kind of error. */
+    readonly kind: string;
+    /** The field associated with this error. */
+    readonly field: FieldTree<unknown>;
+    /** Human readable error message. */
+    readonly message?: string;
+    constructor(options?: ValidationErrorOptions);
+}
 /**
- * Schema path used if the value is an AbstractControl.
+ * An error used to indicate that a required field is empty.
  *
- * @category interop
+ * @category validation
  * @experimental 21.0.0
  */
-type CompatSchemaPath<TControl extends AbstractControl, TPathKind extends PathKind = PathKind.Root> = SchemaPath<TControl extends AbstractControl<unknown, infer TValue> ? TValue : never, SchemaPathRules.Unsupported, TPathKind> & {
-    [ɵɵTYPE]: {
-        control: TControl;
-    };
-};
+declare class RequiredValidationError extends _NgValidationError {
+    readonly kind = "required";
+}
 /**
- * Nested schema path.
- *
- * It mirrors the structure of a given data structure, and allows applying rules to the appropriate
- * fields.
+ * An error used to indicate that a value is lower than the minimum allowed.
  *
+ * @category validation
  * @experimental 21.0.0
  */
-type SchemaPathTree<TModel, TPathKind extends PathKind = PathKind.Root> = ([TModel] extends [AbstractControl] ? CompatSchemaPath<TModel, TPathKind> : SchemaPath<TModel, SchemaPathRules.Supported, TPathKind>) & (TModel extends AbstractControl ? unknown : TModel extends Array<any> ? unknown : TModel extends Record<string, any> ? {
-    [K in keyof TModel]: MaybeSchemaPathTree<TModel[K], PathKind.Child>;
-} : unknown);
+declare class MinValidationError extends _NgValidationError {
+    readonly min: number;
+    readonly kind = "min";
+    constructor(min: number, options?: ValidationErrorOptions);
+}
 /**
- * Helper type for defining `FieldPath`. Given a type `TValue` that may include `undefined`, it
- * extracts the `undefined` outside the `FieldPath` type.
- *
- * For example `MaybeFieldPath<{a: number} | undefined, PathKind.Child>` would be equivalent to
- * `undefined | FieldTree<{a: number}, PathKind.child>`.
- *
- * @template TValue The type of the data which the field is wrapped around.
- * @template TPathKind The kind of path (root field, child field, or item of an array)
+ * An error used to indicate that a value is higher than the maximum allowed.
  *
+ * @category validation
  * @experimental 21.0.0
  */
-type MaybeSchemaPathTree<TModel, TPathKind extends PathKind = PathKind.Root> = (TModel & undefined) | SchemaPathTree<Exclude<TModel, undefined>, TPathKind>;
+declare class MaxValidationError extends _NgValidationError {
+    readonly max: number;
+    readonly kind = "max";
+    constructor(max: number, options?: ValidationErrorOptions);
+}
 /**
- * Defines logic for a form.
- *
- * @template TValue The type of data stored in the form that this schema is attached to.
+ * An error used to indicate that a value is shorter than the minimum allowed length.
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type Schema<in TModel> = {
-    [ɵɵTYPE]: SchemaFn<TModel, PathKind.Root>;
-};
+declare class MinLengthValidationError extends _NgValidationError {
+    readonly minLength: number;
+    readonly kind = "minLength";
+    constructor(minLength: number, options?: ValidationErrorOptions);
+}
 /**
- * Function that defines rules for a schema.
- *
- * @template TModel The type of data stored in the form that this schema function is attached to.
- * @template TPathKind The kind of path this schema function can be bound to.
+ * An error used to indicate that a value is longer than the maximum allowed length.
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type SchemaFn<TModel, TPathKind extends PathKind = PathKind.Root> = (p: SchemaPathTree<TModel, TPathKind>) => void;
+declare class MaxLengthValidationError extends _NgValidationError {
+    readonly maxLength: number;
+    readonly kind = "maxLength";
+    constructor(maxLength: number, options?: ValidationErrorOptions);
+}
 /**
- * A schema or schema definition function.
- *
- * @template TModel The type of data stored in the form that this schema function is attached to.
- * @template TPathKind The kind of path this schema function can be bound to.
+ * An error used to indicate that a value does not match the required pattern.
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type SchemaOrSchemaFn<TModel, TPathKind extends PathKind = PathKind.Root> = Schema<TModel> | SchemaFn<TModel, TPathKind>;
+declare class PatternValidationError extends _NgValidationError {
+    readonly pattern: RegExp;
+    readonly kind = "pattern";
+    constructor(pattern: RegExp, options?: ValidationErrorOptions);
+}
 /**
- * A function that receives the `FieldContext` for the field the logic is bound to and returns
- * a specific result type.
- *
- * @template TValue The data type for the field the logic is bound to.
- * @template TReturn The type of the result returned by the logic function.
- * @template TPathKind The kind of path the logic is applied to (root field, child field, or item of an array)
+ * An error used to indicate that a value is not a valid email.
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type LogicFn<TValue, TReturn, TPathKind extends PathKind = PathKind.Root> = (ctx: FieldContext<TValue, TPathKind>) => TReturn;
+declare class EmailValidationError extends _NgValidationError {
+    readonly kind = "email";
+}
 /**
- * A function that takes the `FieldContext` for the field being validated and returns a
- * `ValidationResult` indicating errors for the field.
- *
- * @template TValue The type of value stored in the field being validated
- * @template TPathKind The kind of path being validated (root field, child field, or item of an array)
+ * An error used to indicate an issue validating against a standard schema.
  *
  * @category validation
  * @experimental 21.0.0
  */
-type FieldValidator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, ValidationResult<ValidationError.WithoutField>, TPathKind>;
+declare class StandardSchemaValidationError extends _NgValidationError {
+    readonly issue: StandardSchemaV1.Issue;
+    readonly kind = "standardSchema";
+    constructor(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions);
+}
 /**
- * A function that takes the `FieldContext` for the field being validated and returns a
- * `TreeValidationResult` indicating errors for the field and its sub-fields.
+ * 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.
  *
- * @template TValue The type of value stored in the field being validated
- * @template TPathKind The kind of path being validated (root field, child field, or item of an array)
+ * @example
+ * ```ts
+ * const f = form(...);
+ * for (const e of form().errors()) {
+ *   if (e instanceof NgValidationError) {
+ *     switch(e.kind) {
+ *       case 'required':
+ *         console.log('This is required!');
+ *         break;
+ *       case 'min':
+ *         console.log(`Must be at least ${e.min}`);
+ *         break;
+ *       ...
+ *     }
+ *   }
+ * }
+ * ```
  *
- * @category types
+ * @category validation
  * @experimental 21.0.0
  */
-type TreeValidator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, TreeValidationResult, TPathKind>;
+declare const NgValidationError: abstract new () => NgValidationError;
+type NgValidationError = RequiredValidationError | MinValidationError | MaxValidationError | MinLengthValidationError | MaxLengthValidationError | PatternValidationError | EmailValidationError | StandardSchemaValidationError;
+
 /**
- * A function that takes the `FieldContext` for the field being validated and returns a
- * `ValidationResult` indicating errors for the field and its sub-fields. In a `Validator` all
- * errors must explicitly define their target field.
- *
- * @template TValue The type of value stored in the field being validated
- * @template TPathKind The kind of path being validated (root field, child field, or item of an array)
- *
- * @category types
- * @experimental 21.0.0
+ * Symbol used to retain generic type information when it would otherwise be lost.
  */
-type Validator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, ValidationResult, TPathKind>;
+declare const ɵɵTYPE: unique symbol;
 /**
- * Provides access to the state of the current field as well as functions that can be used to look
- * up state of other fields based on a `FieldPath`.
+ * A type that represents either a single value of type `T` or a readonly array of `T`.
+ * @template T The type of the value(s).
  *
- * @category types
  * @experimental 21.0.0
  */
-type FieldContext<TValue, TPathKind extends PathKind = PathKind.Root> = TPathKind extends PathKind.Item ? ItemFieldContext<TValue> : TPathKind extends PathKind.Child ? ChildFieldContext<TValue> : RootFieldContext<TValue>;
+type OneOrMany<T> = T | readonly T[];
 /**
- * The base field context that is available for all fields.
+ * The kind of `FieldPath` (`Root`, `Child` of another `FieldPath`, or `Item` in a `FieldPath` array)
  *
  * @experimental 21.0.0
  */
-interface RootFieldContext<TValue> {
-    /** A signal containing the value of the current field. */
-    readonly value: Signal<TValue>;
-    /** The state of the current field. */
-    readonly state: FieldState<TValue>;
-    /** The current field. */
-    readonly field: FieldTree<TValue>;
-    /** Gets the value of the field represented by the given path. */
-    valueOf<PValue>(p: SchemaPath<PValue, SchemaPathRules>): PValue;
-    /** Gets the state of the field represented by the given path. */
-    stateOf<PControl extends AbstractControl>(p: CompatSchemaPath<PControl>): CompatFieldState<PControl>;
-    stateOf<PValue>(p: SchemaPath<PValue, SchemaPathRules>): FieldState<PValue>;
-    /** Gets the field represented by the given path. */
-    fieldTreeOf<PModel>(p: SchemaPathTree<PModel>): FieldTree<PModel>;
-    /** The list of keys that lead from the root field to the current field. */
-    readonly pathKeys: Signal<readonly string[]>;
+type PathKind = PathKind.Root | PathKind.Child | PathKind.Item;
+declare namespace PathKind {
+    /**
+     * The `PathKind` for a `FieldPath` that is at the root of its field tree.
+     */
+    interface Root {
+        /**
+         * The `ɵɵTYPE` is constructed to allow the `extends` clause on `Child` and `Item` to narrow the
+         * type. Another way to think about this is, if we have a function that expects this kind of
+         * path, the `ɵɵTYPE` lists the kinds of path we are allowed to pass to it.
+         */
+        [ɵɵTYPE]: 'root' | 'child' | 'item';
+    }
+    /**
+     * The `PathKind` for a `FieldPath` that is a child of another `FieldPath`.
+     */
+    interface Child extends PathKind.Root {
+        [ɵɵTYPE]: 'child' | 'item';
+    }
+    /**
+     * The `PathKind` for a `FieldPath` that is an item in a `FieldPath` array.
+     */
+    interface Item extends PathKind.Child {
+        [ɵɵTYPE]: 'item';
+    }
 }
 /**
- * Field context that is available for all fields that are a child of another field.
+ * A status indicating whether a field is unsubmitted, submitted, or currently submitting.
  *
- * @category structure
+ * @category types
  * @experimental 21.0.0
  */
-interface ChildFieldContext<TValue> extends RootFieldContext<TValue> {
-    /** The key of the current field in its parent field. */
-    readonly key: Signal<string>;
-}
+type SubmittedStatus = 'unsubmitted' | 'submitted' | 'submitting';
 /**
- * Field context that is available for all fields that are an item in an array field.
+ * A reason for a field's disablement.
  *
+ * @category logic
  * @experimental 21.0.0
  */
-interface ItemFieldContext<TValue> extends ChildFieldContext<TValue> {
-    /** The index of the current field in its parent field. */
-    readonly index: Signal<number>;
+interface DisabledReason {
+    /** The field that is disabled. */
+    readonly field: FieldTree<unknown>;
+    /** A user-facing message describing the reason for the disablement. */
+    readonly message?: string;
 }
 /**
- * Gets the item type of an object that is possibly an array.
+ * The absence of an error which indicates a successful validation result.
  *
+ * @category types
  * @experimental 21.0.0
  */
-type ItemType<T extends Object> = T extends ReadonlyArray<any> ? T[number] : T[keyof T];
+type ValidationSuccess = null | undefined | void;
 /**
- * A function that defines custom debounce logic for a field.
- *
- * @param context The field context.
- * @param abortSignal An `AbortSignal` used to communicate that the debounced operation was aborted.
- * @returns A `Promise<void>` to debounce an update, or `void` to apply an update immediately.
- * @template TValue The type of value stored in the field.
- * @template TPathKind The kind of path the debouncer is applied to (root field, child field, or item of an array).
+ * The result of running a tree validation function.
  *
- * @experimental 21.0.0
- */
-type Debouncer<TValue, TPathKind extends PathKind = PathKind.Root> = (context: FieldContext<TValue, TPathKind>, abortSignal: AbortSignal) => Promise<void> | void;
-
-/**
- * Options used to create a `ValidationError`.
- */
-interface ValidationErrorOptions {
-    /** Human readable error message. */
-    message?: string;
-}
-/**
- * A type that requires the given type `T` to have a `field` property.
- * @template T The type to add a `field` to.
+ * The result may be one of the following:
+ * 1. A {@link ValidationSuccess} to indicate no errors.
+ * 2. A {@link ValidationError} without a field to indicate an error on the field being validated.
+ * 3. A {@link ValidationError} with a field to indicate an error on the target field.
+ * 4. A list of {@link ValidationError} with or without fields to indicate multiple errors.
  *
- * @experimental 21.0.0
- */
-type WithField<T> = T & {
-    field: FieldTree<unknown>;
-};
-/**
- * A type that allows the given type `T` to optionally have a `field` property.
- * @template T The type to optionally add a `field` to.
+ * @template E the type of error (defaults to {@link ValidationError}).
  *
+ * @category types
  * @experimental 21.0.0
  */
-type WithOptionalField<T> = Omit<T, 'field'> & {
-    field?: FieldTree<unknown>;
-};
+type TreeValidationResult<E extends ValidationError.WithOptionalField = ValidationError.WithOptionalField> = ValidationSuccess | OneOrMany<E>;
 /**
- * A type that ensures the given type `T` does not have a `field` property.
- * @template T The type to remove the `field` from.
+ * A validation result where all errors explicitly define their target field.
  *
- * @experimental 21.0.0
- */
-type WithoutField<T> = T & {
-    field: never;
-};
-/**
- * Create a required error associated with the target field
- * @param options The validation error options
+ * The result may be one of the following:
+ * 1. A {@link ValidationSuccess} to indicate no errors.
+ * 2. A {@link ValidationError} with a field to indicate an error on the target field.
+ * 3. A list of {@link ValidationError} with fields to indicate multiple errors.
  *
- * @experimental 21.0.0
- */
-declare function requiredError(options: WithField<ValidationErrorOptions>): RequiredValidationError;
-/**
- * Create a required error
- * @param options The optional validation error options
+ * @template E the type of error (defaults to {@link ValidationError}).
  *
- * @category validation
+ * @category types
  * @experimental 21.0.0
  */
-declare function requiredError(options?: ValidationErrorOptions): WithoutField<RequiredValidationError>;
+type ValidationResult<E extends ValidationError = ValidationError> = ValidationSuccess | OneOrMany<E>;
 /**
- * Create a min value error associated with the target field
- * @param min The min value constraint
- * @param options The validation error options
+ * An asynchronous validation result where all errors explicitly define their target field.
  *
- * @category validation
- * @experimental 21.0.0
- */
-declare function minError(min: number, options: WithField<ValidationErrorOptions>): MinValidationError;
-/**
- * Create a min value error
- * @param min The min value constraint
- * @param options The optional validation error options
+ * The result may be one of the following:
+ * 1. A {@link ValidationResult} to indicate the result if resolved.
+ * 5. 'pending' if the validation is not yet resolved.
  *
- * @category validation
- * @experimental 21.0.0
- */
-declare function minError(min: number, options?: ValidationErrorOptions): WithoutField<MinValidationError>;
-/**
- * Create a max value error associated with the target field
- * @param max The max value constraint
- * @param options The validation error options
+ * @template E the type of error (defaults to {@link ValidationError}).
  *
- * @category validation
+ * @category types
  * @experimental 21.0.0
  */
-declare function maxError(max: number, options: WithField<ValidationErrorOptions>): MaxValidationError;
+type AsyncValidationResult<E extends ValidationError = ValidationError> = ValidationResult<E> | 'pending';
 /**
- * Create a max value error
- * @param max The max value constraint
- * @param options The optional validation error options
+ * An object that represents a tree of fields in a form. This includes both primitive value fields
+ * (e.g. fields that contain a `string` or `number`), as well as "grouping fields" that contain
+ * sub-fields. `FieldTree` objects are arranged in a tree whose structure mimics the structure of the
+ * underlying data. For example a `FieldTree<{x: number}>` has a property `x` which contains a
+ * `FieldTree<number>`. To access the state associated with a field, call it as a function.
  *
- * @category validation
- * @experimental 21.0.0
- */
-declare function maxError(max: number, options?: ValidationErrorOptions): WithoutField<MaxValidationError>;
-/**
- * Create a minLength error associated with the target field
- * @param minLength The minLength constraint
- * @param options The validation error options
+ * @template TValue The type of the data which the field is wrapped around.
+ * @template TKey The type of the property key which this field resides under in its parent.
  *
- * @category validation
+ * @category types
  * @experimental 21.0.0
  */
-declare function minLengthError(minLength: number, options: WithField<ValidationErrorOptions>): MinLengthValidationError;
+type FieldTree<TModel, TKey extends string | number = string | number> = (() => [TModel] extends [AbstractControl] ? CompatFieldState<TModel, TKey> : FieldState<TModel, TKey>) & ([TModel] extends [AbstractControl] ? object : [TModel] extends [Array<infer U>] ? ReadonlyArrayLike<MaybeFieldTree<U, number>> : TModel extends Record<string, any> ? Subfields<TModel> : object);
 /**
- * Create a minLength error
- * @param minLength The minLength constraint
- * @param options The optional validation error options
+ * The sub-fields that a user can navigate to from a `FieldTree<TModel>`.
+ *
+ * @template TModel The type of the data which the parent field is wrapped around.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare function minLengthError(minLength: number, options?: ValidationErrorOptions): WithoutField<MinLengthValidationError>;
+type Subfields<TModel> = {
+    readonly [K in keyof TModel as TModel[K] extends Function ? never : K]: MaybeFieldTree<TModel[K], string>;
+} & {
+    [Symbol.iterator](): Iterator<[string, MaybeFieldTree<TModel[keyof TModel], string>]>;
+};
 /**
- * Create a maxLength error associated with the target field
- * @param maxLength The maxLength constraint
- * @param options The validation error options
+ * An iterable object with the same shape as a readonly array.
+ *
+ * @template T The array item type.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare function maxLengthError(maxLength: number, options: WithField<ValidationErrorOptions>): MaxLengthValidationError;
+type ReadonlyArrayLike<T> = Pick<ReadonlyArray<T>, number | 'length' | typeof Symbol.iterator>;
 /**
- * Create a maxLength error
- * @param maxLength The maxLength constraint
- * @param options The optional validation error options
+ * Helper type for defining `FieldTree`. Given a type `TValue` that may include `undefined`, it extracts
+ * the `undefined` outside the `FieldTree` type.
+ *
+ * For example `MaybeField<{a: number} | undefined, TKey>` would be equivalent to
+ * `undefined | FieldTree<{a: number}, TKey>`.
+ *
+ * @template TModel The type of the data which the field is wrapped around.
+ * @template TKey The type of the property key which this field resides under in its parent.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare function maxLengthError(maxLength: number, options?: ValidationErrorOptions): WithoutField<MaxLengthValidationError>;
+type MaybeFieldTree<TModel, TKey extends string | number = string | number> = (TModel & undefined) | FieldTree<Exclude<TModel, undefined>, TKey>;
 /**
- * Create a pattern matching error associated with the target field
- * @param pattern The violated pattern
- * @param options The validation error options
+ * Contains all of the state (e.g. value, statuses, etc.) associated with a `FieldTree`, exposed as
+ * signals.
  *
- * @category validation
+ * @category structure
  * @experimental 21.0.0
  */
-declare function patternError(pattern: RegExp, options: WithField<ValidationErrorOptions>): PatternValidationError;
+interface FieldState<TValue, TKey extends string | number = string | number> extends _FieldState<TValue> {
+    /**
+     * A signal indicating whether field value has been changed by user.
+     */
+    readonly dirty: Signal<boolean>;
+    /**
+     * A signal indicating whether a field is hidden.
+     *
+     * When a field is hidden it is ignored when determining the valid, touched, and dirty states.
+     *
+     * Note: This doesn't hide the field in the template, that must be done manually.
+     * ```
+     * @if (!field.hidden()) {
+     *   ...
+     * }
+     * ```
+     */
+    readonly hidden: Signal<boolean>;
+    readonly disabledReasons: Signal<readonly DisabledReason[]>;
+    readonly errors: Signal<ValidationError.WithField[]>;
+    /**
+     * A signal containing the {@link errors} of the field and its descendants.
+     */
+    readonly errorSummary: Signal<ValidationError.WithField[]>;
+    /**
+     * A signal indicating whether the field's value is currently valid.
+     *
+     * Note: `valid()` is not the same as `!invalid()`.
+     * - `valid()` is `true` when there are no validation errors *and* no pending validators.
+     * - `invalid()` is `true` when there are validation errors, regardless of pending validators.
+     *
+     * Ex: consider the situation where a field has 3 validators, 2 of which have no errors and 1 of
+     * which is still pending. In this case `valid()` is `false` because of the pending validator.
+     * However `invalid()` is also `false` because there are no errors.
+     */
+    readonly valid: Signal<boolean>;
+    /**
+     * A signal indicating whether the field's value is currently invalid.
+     *
+     * Note: `invalid()` is not the same as `!valid()`.
+     * - `invalid()` is `true` when there are validation errors, regardless of pending validators.
+     * - `valid()` is `true` when there are no validation errors *and* no pending validators.
+     *
+     * Ex: consider the situation where a field has 3 validators, 2 of which have no errors and 1 of
+     * which is still pending. In this case `invalid()` is `false` because there are no errors.
+     * However `valid()` is also `false` because of the pending validator.
+     */
+    readonly invalid: Signal<boolean>;
+    /**
+     * Whether there are any validators still pending for this field.
+     */
+    readonly pending: Signal<boolean>;
+    /**
+     * A signal indicating whether the field is currently in the process of being submitted.
+     */
+    readonly submitting: Signal<boolean>;
+    /**
+     * The property key in the parent field under which this field is stored. If the parent field is
+     * array-valued, for example, this is the index of this field in that array.
+     */
+    readonly keyInParent: Signal<TKey>;
+    /**
+     * The {@link Field} directives that bind this field to a UI control.
+     */
+    readonly fieldBindings: Signal<readonly Field<unknown>[]>;
+    /**
+     * Reads an aggregate metadata value from the field.
+     * @param key The metadata key to read.
+     */
+    metadata<M>(key: AggregateMetadataKey<M, any>): Signal<M>;
+    /**
+     * Reads a metadata value from the field.
+     * @param key The metadata key to read.
+     */
+    metadata<M>(key: MetadataKey<M>): M | undefined;
+    /**
+     * Checks whether the given metadata key has been defined for this field.
+     */
+    hasMetadata(key: MetadataKey<any> | AggregateMetadataKey<any, any>): boolean;
+    /**
+     * 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?: TValue): void;
+}
 /**
- * Create a pattern matching error
- * @param pattern The violated pattern
- * @param options The optional validation error options
+ * This is FieldState also providing access to the wrapped FormControl.
  *
- * @category validation
+ * @category interop
  * @experimental 21.0.0
  */
-declare function patternError(pattern: RegExp, options?: ValidationErrorOptions): WithoutField<PatternValidationError>;
+type CompatFieldState<TControl extends AbstractControl, TKey extends string | number = string | number> = FieldState<TControl extends AbstractControl<unknown, infer TValue> ? TValue : never, TKey> & {
+    control: Signal<TControl>;
+};
 /**
- * Create an email format error associated with the target field
- * @param options The validation error options
+ * Allows declaring whether the Rules are supported for a given path.
  *
- * @category validation
  * @experimental 21.0.0
- */
-declare function emailError(options: WithField<ValidationErrorOptions>): EmailValidationError;
+ **/
+type SchemaPathRules = SchemaPathRules.Supported | SchemaPathRules.Unsupported;
+declare namespace SchemaPathRules {
+    /**
+     * Used for paths that support settings rules.
+     */
+    type Supported = 1;
+    /**
+     * Used for paths that do not support settings rules, e.g., compatPath.
+     */
+    type Unsupported = 2;
+}
 /**
- * Create an email format error
- * @param options The optional validation error options
+ * An object that represents a location in the `FieldTree` tree structure and is used to bind logic to a
+ * particular part of the structure prior to the creation of the form. Because the `FieldPath`
+ * exists prior to the form's creation, it cannot be used to access any of the field state.
  *
- * @category validation
+ * @template TValue The type of the data which the form is wrapped around.
+ * @template TPathKind The kind of path (root field, child field, or item of an array)
+ *
+ * @category types
  * @experimental 21.0.0
  */
-declare function emailError(options?: ValidationErrorOptions): WithoutField<EmailValidationError>;
+type SchemaPath<TValue, TSupportsRules extends SchemaPathRules = SchemaPathRules.Supported, TPathKind extends PathKind = PathKind.Root> = {
+    [ɵɵTYPE]: {
+        value: () => TValue;
+        supportsRules: TSupportsRules;
+        pathKind: TPathKind;
+    };
+};
 /**
- * Create a standard schema issue error associated with the target field
- * @param issue The standard schema issue
- * @param options The validation error options
+ * Schema path used if the value is an AbstractControl.
  *
- * @category validation
+ * @category interop
  * @experimental 21.0.0
  */
-declare function standardSchemaError(issue: StandardSchemaV1.Issue, options: WithField<ValidationErrorOptions>): StandardSchemaValidationError;
+type CompatSchemaPath<TControl extends AbstractControl, TPathKind extends PathKind = PathKind.Root> = SchemaPath<TControl extends AbstractControl<unknown, infer TValue> ? TValue : never, SchemaPathRules.Unsupported, TPathKind> & {
+    [ɵɵTYPE]: {
+        control: TControl;
+    };
+};
 /**
- * Create a standard schema issue error
- * @param issue The standard schema issue
- * @param options The optional validation error options
+ * Nested schema path.
+ *
+ * It mirrors the structure of a given data structure, and allows applying rules to the appropriate
+ * fields.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare function standardSchemaError(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions): WithoutField<StandardSchemaValidationError>;
+type SchemaPathTree<TModel, TPathKind extends PathKind = PathKind.Root> = ([TModel] extends [AbstractControl] ? CompatSchemaPath<TModel, TPathKind> : SchemaPath<TModel, SchemaPathRules.Supported, TPathKind>) & (TModel extends AbstractControl ? unknown : TModel extends Array<any> ? unknown : TModel extends Record<string, any> ? {
+    [K in keyof TModel]: MaybeSchemaPathTree<TModel[K], PathKind.Child>;
+} : unknown);
 /**
- * Create a custom error associated with the target field
- * @param obj The object to create an error from
+ * Helper type for defining `FieldPath`. Given a type `TValue` that may include `undefined`, it
+ * extracts the `undefined` outside the `FieldPath` type.
+ *
+ * For example `MaybeFieldPath<{a: number} | undefined, PathKind.Child>` would be equivalent to
+ * `undefined | FieldTree<{a: number}, PathKind.child>`.
+ *
+ * @template TValue The type of the data which the field is wrapped around.
+ * @template TPathKind The kind of path (root field, child field, or item of an array)
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare function customError<E extends Partial<ValidationError.WithField>>(obj: WithField<E>): CustomValidationError;
+type MaybeSchemaPathTree<TModel, TPathKind extends PathKind = PathKind.Root> = (TModel & undefined) | SchemaPathTree<Exclude<TModel, undefined>, TPathKind>;
 /**
- * Create a custom error
- * @param obj The object to create an error from
+ * Defines logic for a form.
  *
- * @category validation
+ * @template TValue The type of data stored in the form that this schema is attached to.
+ *
+ * @category types
  * @experimental 21.0.0
  */
-declare function customError<E extends Partial<ValidationError.WithField>>(obj?: E): WithoutField<CustomValidationError>;
+type Schema<in TModel> = {
+    [ɵɵTYPE]: SchemaFn<TModel, PathKind.Root>;
+};
 /**
- * Common interface for all validation errors.
- *
- * This can be returned from validators.
+ * Function that defines rules for a schema.
  *
- * It's also used by the creation functions to create an instance
- * (e.g. `requiredError`, `minError`, etc.).
+ * @template TModel The type of data stored in the form that this schema function is attached to.
+ * @template TPathKind The kind of path this schema function can be bound to.
  *
- * @category validation
+ * @category types
  * @experimental 21.0.0
  */
-interface ValidationError {
-    /** Identifies the kind of error. */
-    readonly kind: string;
-    /** Human readable error message. */
-    readonly message?: string;
-}
-declare namespace ValidationError {
-    /**
-     * Validation error with a field.
-     *
-     * This is returned from field state, e.g., catField.errors() would be of a list of errors with
-     * `field: catField` bound to state.
-     */
-    interface WithField extends ValidationError {
-        /** The field associated with this error. */
-        readonly field: FieldTree<unknown>;
-    }
-    /**
-     * Validation error with optional field.
-     *
-     * This is generally used in places where the result might have a field.
-     * e.g., as a result of a `validateTree`, or when handling form submission.
-     */
-    interface WithOptionalField extends ValidationError {
-        /** The field associated with this error. */
-        readonly field?: FieldTree<unknown>;
-    }
-    /**
-     * Validation error with no field.
-     *
-     * This is used to strongly enforce that fields are not allowed in validation result.
-     */
-    interface WithoutField extends ValidationError {
-        /** The field associated with this error. */
-        readonly field?: never;
-    }
-}
+type SchemaFn<TModel, TPathKind extends PathKind = PathKind.Root> = (p: SchemaPathTree<TModel, TPathKind>) => void;
 /**
- * A custom error that may contain additional properties
+ * A schema or schema definition function.
  *
- * @category validation
+ * @template TModel The type of data stored in the form that this schema function is attached to.
+ * @template TPathKind The kind of path this schema function can be bound to.
+ *
+ * @category types
  * @experimental 21.0.0
  */
-declare class CustomValidationError implements ValidationError {
-    /** Brand the class to avoid Typescript structural matching */
-    private __brand;
-    /**
-     * Allow the user to attach arbitrary other properties.
-     */
-    [key: PropertyKey]: unknown;
-    /** Identifies the kind of error. */
-    readonly kind: string;
-    /** The field associated with this error. */
-    readonly field: FieldTree<unknown>;
-    /** Human readable error message. */
-    readonly message?: string;
-    constructor(options?: ValidationErrorOptions);
-}
+type SchemaOrSchemaFn<TModel, TPathKind extends PathKind = PathKind.Root> = Schema<TModel> | SchemaFn<TModel, TPathKind>;
 /**
- * Internal version of `NgValidationError`, we create this separately so we can change its type on
- * the exported version to a type union of the possible sub-classes.
+ * A function that receives the `FieldContext` for the field the logic is bound to and returns
+ * a specific result type.
+ *
+ * @template TValue The data type for the field the logic is bound to.
+ * @template TReturn The type of the result returned by the logic function.
+ * @template TPathKind The kind of path the logic is applied to (root field, child field, or item of an array)
  *
+ * @category types
  * @experimental 21.0.0
  */
-declare abstract class _NgValidationError implements ValidationError {
-    /** Brand the class to avoid Typescript structural matching */
-    private __brand;
-    /** Identifies the kind of error. */
-    readonly kind: string;
-    /** The field associated with this error. */
-    readonly field: FieldTree<unknown>;
-    /** Human readable error message. */
-    readonly message?: string;
-    constructor(options?: ValidationErrorOptions);
-}
+type LogicFn<TValue, TReturn, TPathKind extends PathKind = PathKind.Root> = (ctx: FieldContext<TValue, TPathKind>) => TReturn;
 /**
- * An error used to indicate that a required field is empty.
+ * A function that takes the `FieldContext` for the field being validated and returns a
+ * `ValidationResult` indicating errors for the field.
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TPathKind The kind of path being validated (root field, child field, or item of an array)
  *
  * @category validation
  * @experimental 21.0.0
  */
-declare class RequiredValidationError extends _NgValidationError {
-    readonly kind = "required";
-}
+type FieldValidator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, ValidationResult<ValidationError.WithoutField>, TPathKind>;
 /**
- * An error used to indicate that a value is lower than the minimum allowed.
+ * A function that takes the `FieldContext` for the field being validated and returns a
+ * `TreeValidationResult` indicating errors for the field and its sub-fields.
  *
- * @category validation
+ * @template TValue The type of value stored in the field being validated
+ * @template TPathKind The kind of path being validated (root field, child field, or item of an array)
+ *
+ * @category types
  * @experimental 21.0.0
  */
-declare class MinValidationError extends _NgValidationError {
-    readonly min: number;
-    readonly kind = "min";
-    constructor(min: number, options?: ValidationErrorOptions);
-}
+type TreeValidator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, TreeValidationResult, TPathKind>;
 /**
- * An error used to indicate that a value is higher than the maximum allowed.
+ * A function that takes the `FieldContext` for the field being validated and returns a
+ * `ValidationResult` indicating errors for the field and its sub-fields. In a `Validator` all
+ * errors must explicitly define their target field.
  *
- * @category validation
+ * @template TValue The type of value stored in the field being validated
+ * @template TPathKind The kind of path being validated (root field, child field, or item of an array)
+ *
+ * @category types
  * @experimental 21.0.0
  */
-declare class MaxValidationError extends _NgValidationError {
-    readonly max: number;
-    readonly kind = "max";
-    constructor(max: number, options?: ValidationErrorOptions);
-}
+type Validator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, ValidationResult, TPathKind>;
 /**
- * An error used to indicate that a value is shorter than the minimum allowed length.
+ * Provides access to the state of the current field as well as functions that can be used to look
+ * up state of other fields based on a `FieldPath`.
  *
- * @category validation
+ * @category types
  * @experimental 21.0.0
  */
-declare class MinLengthValidationError extends _NgValidationError {
-    readonly minLength: number;
-    readonly kind = "minLength";
-    constructor(minLength: number, options?: ValidationErrorOptions);
-}
+type FieldContext<TValue, TPathKind extends PathKind = PathKind.Root> = TPathKind extends PathKind.Item ? ItemFieldContext<TValue> : TPathKind extends PathKind.Child ? ChildFieldContext<TValue> : RootFieldContext<TValue>;
 /**
- * An error used to indicate that a value is longer than the maximum allowed length.
+ * The base field context that is available for all fields.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare class MaxLengthValidationError extends _NgValidationError {
-    readonly maxLength: number;
-    readonly kind = "maxLength";
-    constructor(maxLength: number, options?: ValidationErrorOptions);
+interface RootFieldContext<TValue> {
+    /** A signal containing the value of the current field. */
+    readonly value: Signal<TValue>;
+    /** The state of the current field. */
+    readonly state: FieldState<TValue>;
+    /** The current field. */
+    readonly field: FieldTree<TValue>;
+    /** Gets the value of the field represented by the given path. */
+    valueOf<PValue>(p: SchemaPath<PValue, SchemaPathRules>): PValue;
+    /** Gets the state of the field represented by the given path. */
+    stateOf<PControl extends AbstractControl>(p: CompatSchemaPath<PControl>): CompatFieldState<PControl>;
+    stateOf<PValue>(p: SchemaPath<PValue, SchemaPathRules>): FieldState<PValue>;
+    /** Gets the field represented by the given path. */
+    fieldTreeOf<PModel>(p: SchemaPathTree<PModel>): FieldTree<PModel>;
+    /** The list of keys that lead from the root field to the current field. */
+    readonly pathKeys: Signal<readonly string[]>;
 }
 /**
- * An error used to indicate that a value does not match the required pattern.
+ * Field context that is available for all fields that are a child of another field.
  *
- * @category validation
+ * @category structure
  * @experimental 21.0.0
  */
-declare class PatternValidationError extends _NgValidationError {
-    readonly pattern: RegExp;
-    readonly kind = "pattern";
-    constructor(pattern: RegExp, options?: ValidationErrorOptions);
+interface ChildFieldContext<TValue> extends RootFieldContext<TValue> {
+    /** The key of the current field in its parent field. */
+    readonly key: Signal<string>;
 }
 /**
- * An error used to indicate that a value is not a valid email.
+ * Field context that is available for all fields that are an item in an array field.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare class EmailValidationError extends _NgValidationError {
-    readonly kind = "email";
+interface ItemFieldContext<TValue> extends ChildFieldContext<TValue> {
+    /** The index of the current field in its parent field. */
+    readonly index: Signal<number>;
 }
 /**
- * An error used to indicate an issue validating against a standard schema.
+ * Gets the item type of an object that is possibly an array.
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare class StandardSchemaValidationError extends _NgValidationError {
-    readonly issue: StandardSchemaV1.Issue;
-    readonly kind = "standardSchema";
-    constructor(issue: StandardSchemaV1.Issue, options?: ValidationErrorOptions);
-}
+type ItemType<T extends Object> = T extends ReadonlyArray<any> ? T[number] : T[keyof T];
 /**
- * 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.
+ * A function that defines custom debounce logic for a field.
  *
- * @example
- * ```ts
- * const f = form(...);
- * for (const e of form().errors()) {
- *   if (e instanceof NgValidationError) {
- *     switch(e.kind) {
- *       case 'required':
- *         console.log('This is required!');
- *         break;
- *       case 'min':
- *         console.log(`Must be at least ${e.min}`);
- *         break;
- *       ...
- *     }
- *   }
- * }
- * ```
+ * @param context The field context.
+ * @param abortSignal An `AbortSignal` used to communicate that the debounced operation was aborted.
+ * @returns A `Promise<void>` to debounce an update, or `void` to apply an update immediately.
+ * @template TValue The type of value stored in the field.
+ * @template TPathKind The kind of path the debouncer is applied to (root field, child field, or item of an array).
  *
- * @category validation
  * @experimental 21.0.0
  */
-declare const NgValidationError: abstract new () => NgValidationError;
-type NgValidationError = RequiredValidationError | MinValidationError | MaxValidationError | MinLengthValidationError | MaxLengthValidationError | PatternValidationError | EmailValidationError | StandardSchemaValidationError;
+type Debouncer<TValue, TPathKind extends PathKind = PathKind.Root> = (context: FieldContext<TValue, TPathKind>, abortSignal: AbortSignal) => Promise<void> | void;
 
 /**
  * Configuration options for signal forms.
@@ -1242,27 +1205,41 @@ declare class LogicContainer {
     readonly syncTreeErrors: ArrayMergeIgnoreLogic<ValidationError.WithField, null>;
     /** Logic that produces asynchronous validation results (errors or 'pending'). */
     readonly asyncErrors: ArrayMergeIgnoreLogic<ValidationError.WithField | 'pending', null>;
-    /** A map of metadata keys to the `AbstractLogic` instances that compute their values. */
-    private readonly metadata;
+    /** A map of aggregate metadata keys to the `AbstractLogic` instances that compute their values. */
+    private readonly aggregateMetadataKeys;
+    /** A map of metadata keys to the factory functions that create their values. */
+    private readonly metadataFactories;
     /**
      * 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;
+    /** Checks whether there is logic for the given aggregate metadata key. */
+    hasAggregateMetadata(key: AggregateMetadataKey<any, any>): boolean;
+    /**
+     * Gets an iterable of [aggregate metadata, logic function] pairs.
+     * @returns An iterable of aggregate metadata entries.
+     */
+    getAggregateMetadataEntries(): MapIterator<[AggregateMetadataKey<unknown, unknown>, AbstractLogic<unknown, unknown>]>;
     /**
-     * Gets an iterable of [metadata key, logic function] pairs.
-     * @returns An iterable of metadata keys.
+     * Gets an iterable of [metadata, value factory function] pairs.
+     * @returns An iterable of metadata factory entries.
      */
-    getMetadataKeys(): MapIterator<MetadataKey<unknown, unknown, unknown>>;
+    getMetadataFactoryEntries(): MapIterator<[MetadataKey<unknown>, (ctx: FieldContext<unknown>) => unknown]>;
     /**
-     * Retrieves or creates the `AbstractLogic` for a given metadata key.
-     * @param key The `MetadataKey` for which to get the logic.
+     * Retrieves or creates the `AbstractLogic` for a given aggregate metadata key.
+     * @param key The `AggregateMetadataKey` for which to get the logic.
      * @returns The `AbstractLogic` associated with the key.
      */
-    getMetadata<T>(key: MetadataKey<any, T, any>): AbstractLogic<T>;
+    getAggregateMetadata<T>(key: AggregateMetadataKey<any, T>): AbstractLogic<T>;
+    /**
+     * Adds a factory function for a given metadata key.
+     * @param key The `MetadataKey` to associate the factory with.
+     * @param factory The factory function.
+     * @throws If a factory is already defined for the given key.
+     */
+    addMetadataFactory(key: MetadataKey<unknown>, factory: (ctx: FieldContext<unknown>) => unknown): void;
     /**
      * Merges logic from another `Logic` instance into this one.
      * @param other The `Logic` instance to merge from.
@@ -1294,8 +1271,10 @@ declare abstract class AbstractLogicNodeBuilder {
     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;
+    /** Adds a rule to compute aggregate metadata for a field. */
+    abstract addAggregateMetadataRule<M>(key: AggregateMetadataKey<unknown, M>, logic: LogicFn<any, M>): void;
+    /** Adds a factory function to produce a data value associated with a field. */
+    abstract addMetadataFactory<D>(key: MetadataKey<D>, factory: (ctx: FieldContext<any>) => D): void;
     /**
      * Gets a builder for a child node associated with the given property key.
      * @param key The property key of the child.
@@ -1341,7 +1320,8 @@ declare class LogicNodeBuilder extends AbstractLogicNodeBuilder {
     addSyncErrorRule(logic: LogicFn<any, ValidationResult<ValidationError.WithField>>): void;
     addSyncTreeErrorRule(logic: LogicFn<any, ValidationResult<ValidationError.WithField>>): void;
     addAsyncErrorRule(logic: LogicFn<any, AsyncValidationResult<ValidationError.WithField>>): void;
-    addMetadataRule<T>(key: MetadataKey<unknown, T, any>, logic: LogicFn<any, T>): void;
+    addAggregateMetadataRule<T>(key: AggregateMetadataKey<any, T>, logic: LogicFn<any, T>): void;
+    addMetadataFactory<D>(key: MetadataKey<D>, factory: (ctx: FieldContext<any>) => D): void;
     getChild(key: PropertyKey): LogicNodeBuilder;
     hasLogic(builder: AbstractLogicNodeBuilder): boolean;
     /**
@@ -1470,13 +1450,13 @@ declare class FieldPathNode {
  */
 declare class FieldMetadataState {
     private readonly node;
-    /** A map of all `MetadataKey` that have been defined for this field. */
+    /** A map of all `MetadataKey` and `AggregateMetadataKey` 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;
+    /** Gets the value of a `MetadataKey` or `AggregateMetadataKey` for the field. */
+    get<T>(key: MetadataKey<T> | AggregateMetadataKey<T, unknown>): T | undefined | Signal<T>;
     /** Checks whether the current metadata state has the given metadata key. */
-    has(key: MetadataKey<any, any, any>): boolean;
+    has(key: MetadataKey<any> | AggregateMetadataKey<any, any>): boolean;
 }
 
 /**
@@ -1715,7 +1695,6 @@ declare class FieldNode implements FieldState<unknown> {
      * Proxy to this node which allows navigation of the form graph below it.
      */
     readonly fieldProxy: FieldTree<any>;
-    private readonly pathNode;
     constructor(options: FieldNodeOptions);
     /**
      * The `AbortController` for the currently debounced sync, or `undefined` if there is none.
@@ -1744,14 +1723,16 @@ declare class FieldNode implements FieldState<unknown> {
     get fieldBindings(): Signal<readonly Field<unknown>[]>;
     get submitting(): Signal<boolean>;
     get name(): Signal<string>;
+    private metadataOrUndefined;
     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;
+    metadata<M>(key: AggregateMetadataKey<M, any>): Signal<M>;
+    metadata<M>(key: MetadataKey<M>): M | undefined;
+    hasMetadata(key: MetadataKey<any> | AggregateMetadataKey<any, any>): boolean;
     /**
      * Marks this specific field as touched.
      */
@@ -1791,8 +1772,11 @@ declare class FieldNode implements FieldState<unknown> {
      * Creates a new root field node for a new form.
      */
     static newRoot<T>(fieldManager: FormFieldManager, value: WritableSignal<T>, pathNode: FieldPathNode, adapter: FieldAdapter): FieldNode;
+    /**
+     * Creates a child field node based on the given options.
+     */
+    private static newChild;
     createStructure(options: FieldNodeOptions): RootFieldNodeStructure | ChildFieldNodeStructure;
-    private newChild;
 }
 /**
  * Field node of a field that has children.
@@ -1814,16 +1798,12 @@ interface ParentFieldNode extends FieldNode {
 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 logic to apply to this field. */
+    readonly logic: LogicNode;
+    /** Computed map of child fields, based on the current value of this field. */
+    abstract readonly childrenMap: Signal<Map<TrackingKey, FieldNode> | undefined>;
     /** The field's value. */
     abstract readonly value: WritableSignal<unknown>;
     /**
@@ -1839,60 +1819,33 @@ declare abstract class FieldNodeStructure {
     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);
+    constructor(
+    /** The logic to apply to this field. */
+    logic: LogicNode);
     /** Gets the child fields of this field. */
     children(): Iterable<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 {
+    /** The full field node that corresponds to this structure. */
+    private readonly node;
     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>;
+    readonly childrenMap: Signal<Map<TrackingKey, FieldNode> | undefined>;
     /**
      * Creates the structure for the root node of a field tree.
      *
@@ -1906,17 +1859,16 @@ declare class RootFieldNodeStructure extends FieldNodeStructure {
      */
     constructor(
     /** The full field node that corresponds to this structure. */
-    node: FieldNode, logic: LogicNode, fieldManager: FormFieldManager, value: WritableSignal<unknown>, createChildNode: ChildNodeCtor);
+    node: FieldNode, pathNode: FieldPathNode, logic: LogicNode, fieldManager: FormFieldManager, value: WritableSignal<unknown>, adapter: FieldAdapter, createChildNode: (options: ChildFieldNodeOptions) => FieldNode);
 }
 /** 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>;
+    readonly childrenMap: Signal<Map<TrackingKey, FieldNode> | undefined>;
     get fieldManager(): FormFieldManager;
     /**
      * Creates the structure for a child field node in a field tree.
@@ -1930,7 +1882,7 @@ declare class ChildFieldNodeStructure extends FieldNodeStructure {
      * @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);
+    constructor(node: FieldNode, pathNode: FieldPathNode, logic: LogicNode, parent: ParentFieldNode, identityInParent: TrackingKey | undefined, initialKeyInParent: string, adapter: FieldAdapter, createChildNode: (options: ChildFieldNodeOptions) => FieldNode);
 }
 /** Options passed when constructing a root field node. */
 interface RootFieldNodeOptions {
@@ -1966,38 +1918,6 @@ interface ChildFieldNodeOptions {
 }
 /** 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`.
@@ -2344,5 +2264,5 @@ declare function submit<TModel>(form: FieldTree<TModel>, action: (form: FieldTre
  */
 declare function schema<TValue>(fn: SchemaFn<TValue>): Schema<TValue>;
 
-export { CustomValidationError, EmailValidationError, FIELD, Field, 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, customError, 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, FormOptions, ItemFieldContext, ItemType, LogicFn, MaybeFieldTree, MaybeSchemaPathTree, MetadataSetterType, OneOrMany, ReadonlyArrayLike, RootFieldContext, Schema, SchemaFn, SchemaOrSchemaFn, SchemaPath, SchemaPathTree, SignalFormsConfig, Subfields, SubmittedStatus, TreeValidationResult, TreeValidator, ValidationResult, ValidationSuccess, Validator, WithField, WithOptionalField, WithoutField };
+export { AggregateMetadataKey, CustomValidationError, EmailValidationError, FIELD, Field, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MetadataKey, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PathKind, PatternValidationError, REQUIRED, RequiredValidationError, SchemaPathRules, StandardSchemaValidationError, ValidationError, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, createMetadataKey, customError, emailError, form, listMetadataKey, maxError, maxLengthError, maxMetadataKey, minError, minLengthError, minMetadataKey, orMetadataKey, patternError, provideSignalFormsConfig, reducedMetadataKey, requiredError, schema, standardSchemaError, submit };
+export type { AsyncValidationResult, ChildFieldContext, CompatFieldState, CompatSchemaPath, Debouncer, DisabledReason, FieldContext, FieldState, FieldTree, FieldValidator, FormOptions, ItemFieldContext, ItemType, LogicFn, MaybeFieldTree, MaybeSchemaPathTree, OneOrMany, ReadonlyArrayLike, RootFieldContext, Schema, SchemaFn, SchemaOrSchemaFn, SchemaPath, SchemaPathTree, SignalFormsConfig, Subfields, SubmittedStatus, TreeValidationResult, TreeValidator, ValidationResult, ValidationSuccess, Validator, WithField, WithOptionalField, WithoutField };