@angular/forms 21.0.0-rc.1 → 21.0.0-rc.2

package/types/signals.d.ts

@@ -1,12 +1,13 @@
 /**
- * @license Angular v21.0.0-rc.1
+ * @license Angular v21.0.0-rc.2
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
 import { HttpResourceRequest, HttpResourceOptions } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { InjectionToken, ɵControl as _Control, ɵCONTROL as _CONTROL, ɵFieldState as _FieldState, Signal, ResourceRef, InputSignal, ModelSignal, OutputRef, WritableSignal, DestroyableInjector, Injector } from '@angular/core';
+import { InjectionToken, ɵControl as _Control, ɵCONTROL as _CONTROL, ɵInteropControl as _InteropControl, ɵFieldState as _FieldState, Signal, ResourceRef, InputSignal, ModelSignal, OutputRef, 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';
 
@@ -71,19 +72,16 @@ declare const FIELD: InjectionToken<Field<unknown>>;
 declare class Field<T> implements _Control<T> {
     private readonly injector;
     readonly field: i0.InputSignal<FieldTree<T>>;
-    readonly state: i0.Signal<FieldState<T, string | number>>;
+    readonly state: i0.Signal<[T] extends [_angular_forms.AbstractControl<any, any, any>] ? CompatFieldState<T, string | number> : FieldState<T, string | number>>;
     readonly [_CONTROL]: undefined;
     /** 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. */
-    private get controlValueAccessor();
-    get ɵhasInteropControl(): boolean;
+    get ɵinteropControl(): _InteropControl | undefined;
     /** Lazily instantiates a fake `NgControl` for this field. */
-    ɵgetOrCreateNgControl(): InteropNgControl;
-    ɵinteropControlCreate(): void;
-    ɵinteropControlUpdate(): void;
+    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>;
@@ -130,7 +128,7 @@ declare class AggregateMetadataKey<TAcc, TItem> {
  *
  * @experimental 21.0.0
  */
-declare function reducedMetadataKey<TAcc, TItem>(reduce: (acc: TAcc, item: TItem) => TAcc, getInitial: () => TAcc): AggregateMetadataKey<TAcc, TItem>;
+declare function reducedMetadataKey<TAcc, TItem>(reduce: (acc: TAcc, item: TItem) => TAcc, getInitial: NoInfer<() => TAcc>): AggregateMetadataKey<TAcc, TItem>;
 /**
  * Creates an {@link AggregateMetadataKey} that reduces its individual values into a list.
  *
@@ -386,7 +384,7 @@ declare function standardSchemaError(issue: StandardSchemaV1.Issue, options?: Va
  * @category validation
  * @experimental 21.0.0
  */
-declare function customError<E extends Partial<ValidationErrorWithField>>(obj: WithField<E>): CustomValidationError;
+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
@@ -394,7 +392,7 @@ declare function customError<E extends Partial<ValidationErrorWithField>>(obj: W
  * @category validation
  * @experimental 21.0.0
  */
-declare function customError<E extends Partial<ValidationErrorWithField>>(obj?: E): WithoutField<CustomValidationError>;
+declare function customError<E extends Partial<ValidationError.WithField>>(obj?: E): WithoutField<CustomValidationError>;
 /**
  * Common interface for all validation errors.
  *
@@ -412,34 +410,36 @@ interface ValidationError {
     /** Human readable error message. */
     readonly message?: string;
 }
-/**
- * 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 ValidationErrorWithField 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 ValidationErrorWithOptionalField 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 ValidationErrorWithoutField extends ValidationError {
-    /** The field associated with this error. */
-    readonly field?: never;
+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;
+    }
 }
 /**
  * A custom error that may contain additional properties
@@ -673,7 +673,7 @@ type ValidationSuccess = null | undefined | void;
  * @category types
  * @experimental 21.0.0
  */
-type TreeValidationResult<E extends ValidationErrorWithOptionalField = ValidationErrorWithOptionalField> = ValidationSuccess | OneOrMany<E>;
+type TreeValidationResult<E extends ValidationError.WithOptionalField = ValidationError.WithOptionalField> = ValidationSuccess | OneOrMany<E>;
 /**
  * A validation result where all errors explicitly define their target field.
  *
@@ -714,16 +714,18 @@ type AsyncValidationResult<E extends ValidationError = ValidationError> = Valida
  * @category types
  * @experimental 21.0.0
  */
-type FieldTree<TValue, TKey extends string | number = string | number> = (() => FieldState<TValue, TKey>) & (TValue extends Array<infer U> ? ReadonlyArrayLike<MaybeFieldTree<U, number>> : TValue extends Record<string, any> ? Subfields<TValue> : unknown);
+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);
 /**
- * The sub-fields that a user can navigate to from a `FieldTree<TValue>`.
+ * The sub-fields that a user can navigate to from a `FieldTree<TModel>`.
  *
- * @template TValue The type of the data which the parent field is wrapped around.
+ * @template TModel The type of the data which the parent field is wrapped around.
  *
  * @experimental 21.0.0
  */
-type Subfields<TValue> = {
-    readonly [K in keyof TValue as TValue[K] extends Function ? never : K]: MaybeFieldTree<TValue[K], string>;
+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>]>;
 };
 /**
  * An iterable object with the same shape as a readonly array.
@@ -740,12 +742,12 @@ type ReadonlyArrayLike<T> = Pick<ReadonlyArray<T>, number | 'length' | typeof Sy
  * For example `MaybeField<{a: number} | undefined, TKey>` would be equivalent to
  * `undefined | FieldTree<{a: number}, TKey>`.
  *
- * @template TValue The type of the data which the field is wrapped around.
+ * @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.
  *
  * @experimental 21.0.0
  */
-type MaybeFieldTree<TValue, TKey extends string | number = string | number> = (TValue & undefined) | FieldTree<Exclude<TValue, undefined>, TKey>;
+type MaybeFieldTree<TModel, TKey extends string | number = string | number> = (TModel & undefined) | FieldTree<Exclude<TModel, undefined>, TKey>;
 /**
  * Contains all of the state (e.g. value, statuses, etc.) associated with a `FieldTree`, exposed as
  * signals.
@@ -772,11 +774,11 @@ interface FieldState<TValue, TKey extends string | number = string | number> ext
      */
     readonly hidden: Signal<boolean>;
     readonly disabledReasons: Signal<readonly DisabledReason[]>;
-    readonly errors: Signal<ValidationErrorWithField[]>;
+    readonly errors: Signal<ValidationError.WithField[]>;
     /**
      * A signal containing the {@link errors} of the field and its descendants.
      */
-    readonly errorSummary: Signal<ValidationErrorWithField[]>;
+    readonly errorSummary: Signal<ValidationError.WithField[]>;
     /**
      * A signal indicating whether the field's value is currently valid.
      *
@@ -839,6 +841,31 @@ interface FieldState<TValue, TKey extends string | number = string | number> ext
      */
     reset(): void;
 }
+/**
+ * This is FieldState also providing access to the wrapped FormControl.
+ *
+ * @category interop
+ * @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;
+    /**
+     * Used for paths that do not support settings rules, e.g., compatPath.
+     */
+    type Unsupported = 2;
+}
 /**
  * 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`
@@ -850,10 +877,34 @@ interface FieldState<TValue, TKey extends string | number = string | number> ext
  * @category types
  * @experimental 21.0.0
  */
-type FieldPath<TValue, TPathKind extends PathKind = PathKind.Root> = {
-    [ɵɵTYPE]: [TValue, TPathKind];
-} & (TValue extends Array<unknown> ? unknown : TValue extends Record<string, any> ? {
-    [K in keyof TValue]: MaybeFieldPath<TValue[K], PathKind.Child>;
+type SchemaPath<TValue, TSupportsRules extends SchemaPathRules = SchemaPathRules.Supported, TPathKind extends PathKind = PathKind.Root> = {
+    [ɵɵTYPE]: {
+        value: () => TValue;
+        supportsRules: TSupportsRules;
+        pathKind: TPathKind;
+    };
+};
+/**
+ * Schema path used if the value is an AbstractControl.
+ *
+ * @category interop
+ * @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;
+    };
+};
+/**
+ * Nested schema path.
+ *
+ * It mirrors the structure of a given data structure, and allows applying rules to the appropriate
+ * fields.
+ *
+ * @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);
 /**
  * Helper type for defining `FieldPath`. Given a type `TValue` that may include `undefined`, it
@@ -867,7 +918,7 @@ type FieldPath<TValue, TPathKind extends PathKind = PathKind.Root> = {
  *
  * @experimental 21.0.0
  */
-type MaybeFieldPath<TValue, TPathKind extends PathKind = PathKind.Root> = (TValue & undefined) | FieldPath<Exclude<TValue, undefined>, TPathKind>;
+type MaybeSchemaPathTree<TModel, TPathKind extends PathKind = PathKind.Root> = (TModel & undefined) | SchemaPathTree<Exclude<TModel, undefined>, TPathKind>;
 /**
  * Defines logic for a form.
  *
@@ -876,29 +927,29 @@ type MaybeFieldPath<TValue, TPathKind extends PathKind = PathKind.Root> = (TValu
  * @category types
  * @experimental 21.0.0
  */
-type Schema<in TValue> = {
-    [ɵɵTYPE]: SchemaFn<TValue, PathKind.Root>;
+type Schema<in TModel> = {
+    [ɵɵTYPE]: SchemaFn<TModel, PathKind.Root>;
 };
 /**
  * Function that defines rules for a schema.
  *
- * @template TValue The type of data stored in the form that this schema function is attached to.
+ * @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
  */
-type SchemaFn<TValue, TPathKind extends PathKind = PathKind.Root> = (p: FieldPath<TValue, TPathKind>) => void;
+type SchemaFn<TModel, TPathKind extends PathKind = PathKind.Root> = (p: SchemaPathTree<TModel, TPathKind>) => void;
 /**
  * A schema or schema definition function.
  *
- * @template TValue The type of data stored in the form that this schema function is attached to.
+ * @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
  */
-type SchemaOrSchemaFn<TValue, TPathKind extends PathKind = PathKind.Root> = Schema<TValue> | SchemaFn<TValue, TPathKind>;
+type SchemaOrSchemaFn<TModel, TPathKind extends PathKind = PathKind.Root> = Schema<TModel> | SchemaFn<TModel, TPathKind>;
 /**
  * A function that receives the `FieldContext` for the field the logic is bound to and returns
  * a specific result type.
@@ -921,7 +972,7 @@ type LogicFn<TValue, TReturn, TPathKind extends PathKind = PathKind.Root> = (ctx
  * @category validation
  * @experimental 21.0.0
  */
-type FieldValidator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, ValidationResult<ValidationErrorWithoutField>, TPathKind>;
+type FieldValidator<TValue, TPathKind extends PathKind = PathKind.Root> = LogicFn<TValue, ValidationResult<ValidationError.WithoutField>, TPathKind>;
 /**
  * A function that takes the `FieldContext` for the field being validated and returns a
  * `TreeValidationResult` indicating errors for the field and its sub-fields.
@@ -966,11 +1017,14 @@ interface RootFieldContext<TValue> {
     /** The current field. */
     readonly field: FieldTree<TValue>;
     /** Gets the value of the field represented by the given path. */
-    readonly valueOf: <P>(p: FieldPath<P>) => P;
+    valueOf<PValue>(p: SchemaPath<PValue, SchemaPathRules>): PValue;
     /** Gets the state of the field represented by the given path. */
-    readonly stateOf: <P>(p: FieldPath<P>) => FieldState<P>;
+    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. */
-    readonly fieldOf: <P>(p: FieldPath<P>) => FieldTree<P>;
+    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[]>;
 }
 /**
  * Field context that is available for all fields that are a child of another field.
@@ -991,6 +1045,24 @@ interface ItemFieldContext<TValue> extends ChildFieldContext<TValue> {
     /** The index of the current field in its parent field. */
     readonly index: Signal<number>;
 }
+/**
+ * Gets the item type of an object that is possibly an array.
+ *
+ * @experimental 21.0.0
+ */
+type ItemType<T extends Object> = T extends ReadonlyArray<any> ? T[number] : T[keyof T];
+/**
+ * A function that defines custom debounce logic for a field.
+ *
+ * This function receives the {@link FieldContext} for the field and should return a `Promise<void>`
+ * to delay 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).
+ *
+ * @experimental 21.0.0
+ */
+type Debouncer<TValue, TPathKind extends PathKind = PathKind.Root> = (context: FieldContext<TValue, TPathKind>) => Promise<void> | void;
 
 /**
  * A function that takes the result of an async operation and the current field context, and maps it
@@ -1112,7 +1184,7 @@ interface HttpValidatorOptions<TValue, TResult, TPathKind extends PathKind = Pat
  * @category validation
  * @experimental 21.0.0
  */
-declare function validateAsync<TValue, TParams, TResult, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, opts: AsyncValidatorOptions<TValue, TParams, TResult, TPathKind>): void;
+declare function validateAsync<TValue, TParams, TResult, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, opts: AsyncValidatorOptions<TValue, TParams, TResult, TPathKind>): void;
 /**
  * Adds async validation to the field corresponding to the given path based on an httpResource.
  * Async validation for a field only runs once all synchronous validation is passing.
@@ -1126,7 +1198,7 @@ declare function validateAsync<TValue, TParams, TResult, TPathKind extends PathK
  * @category validation
  * @experimental 21.0.0
  */
-declare function validateHttp<TValue, TResult = unknown, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, opts: HttpValidatorOptions<TValue, TResult, TPathKind>): void;
+declare function validateHttp<TValue, TResult = unknown, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, opts: HttpValidatorOptions<TValue, TResult, TPathKind>): void;
 
 /**
  * The base set of properties shared by all form control contracts.
@@ -1267,6 +1339,20 @@ interface FormCheckboxControl extends FormUiControl {
     readonly value?: undefined;
 }
 
+/**
+ * Configures the frequency at which a form field is updated by UI events.
+ *
+ * When this rule is applied, updates from the UI to the form model will be delayed until either
+ * the field is touched, or the most recently debounced update resolves.
+ *
+ * @param path The target path to debounce.
+ * @param durationOrDebouncer Either a debounce duration in milliseconds, or a custom
+ *     {@link Debouncer} function.
+ *
+ * @experimental 21.0.0
+ */
+declare function debounce<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, durationOrDebouncer: number | Debouncer<TValue, TPathKind>): void;
+
 /**
  * Adds logic to a field to conditionally disable it. A disabled field does not contribute to the
  * validation, touched/dirty, or other state of its parent field.
@@ -1280,7 +1366,7 @@ interface FormCheckboxControl extends FormUiControl {
  * @category logic
  * @experimental 21.0.0
  */
-declare function disabled<TValue, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, logic?: string | NoInfer<LogicFn<TValue, boolean | string, TPathKind>>): void;
+declare function disabled<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, logic?: string | NoInfer<LogicFn<TValue, boolean | string, TPathKind>>): void;
 /**
  * Adds logic to a field to conditionally make it readonly. A readonly field does not contribute to
  * the validation, touched/dirty, or other state of its parent field.
@@ -1293,7 +1379,7 @@ declare function disabled<TValue, TPathKind extends PathKind = PathKind.Root>(pa
  * @category logic
  * @experimental 21.0.0
  */
-declare function readonly<TValue, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, logic?: NoInfer<LogicFn<TValue, boolean, TPathKind>>): void;
+declare function readonly<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, logic?: NoInfer<LogicFn<TValue, boolean, TPathKind>>): void;
 /**
  * Adds logic to a field to conditionally hide it. A hidden field does not contribute to the
  * validation, touched/dirty, or other state of its parent field.
@@ -1314,7 +1400,7 @@ declare function readonly<TValue, TPathKind extends PathKind = PathKind.Root>(pa
  * @category logic
  * @experimental 21.0.0
  */
-declare function hidden<TValue, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, logic: NoInfer<LogicFn<TValue, boolean, TPathKind>>): void;
+declare function hidden<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, logic: NoInfer<LogicFn<TValue, boolean, TPathKind>>): void;
 /**
  * Adds logic to a field to determine if the field has validation errors.
  *
@@ -1326,7 +1412,7 @@ declare function hidden<TValue, TPathKind extends PathKind = PathKind.Root>(path
  * @category logic
  * @experimental 21.0.0
  */
-declare function validate<TValue, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, logic: NoInfer<FieldValidator<TValue, TPathKind>>): void;
+declare function validate<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, logic: NoInfer<FieldValidator<TValue, TPathKind>>): void;
 /**
  * Adds logic to a field to determine if the field or any of its child fields has validation errors.
  *
@@ -1339,7 +1425,7 @@ declare function validate<TValue, TPathKind extends PathKind = PathKind.Root>(pa
  * @category logic
  * @experimental 21.0.0
  */
-declare function validateTree<TValue, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, logic: NoInfer<TreeValidator<TValue, TPathKind>>): void;
+declare function validateTree<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, logic: NoInfer<TreeValidator<TValue, TPathKind>>): void;
 /**
  * Adds a value to an {@link AggregateMetadataKey} of a field.
  *
@@ -1353,7 +1439,7 @@ declare function validateTree<TValue, TPathKind extends PathKind = PathKind.Root
  * @category logic
  * @experimental 21.0.0
  */
-declare function aggregateMetadata<TValue, TMetadataItem, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, key: AggregateMetadataKey<any, TMetadataItem>, logic: NoInfer<LogicFn<TValue, TMetadataItem, TPathKind>>): void;
+declare function aggregateMetadata<TValue, TMetadataItem, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, key: AggregateMetadataKey<any, TMetadataItem>, logic: NoInfer<LogicFn<TValue, TMetadataItem, TPathKind>>): void;
 /**
  * Creates a new {@link MetadataKey} and defines the value of the new metadata key for the given field.
  *
@@ -1365,7 +1451,7 @@ declare function aggregateMetadata<TValue, TMetadataItem, TPathKind extends Path
  * @category logic
  * @experimental 21.0.0
  */
-declare function metadata<TValue, TData, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, factory: (ctx: FieldContext<TValue, TPathKind>) => TData): MetadataKey<TData>;
+declare function metadata<TValue, TData, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, factory: (ctx: FieldContext<TValue, TPathKind>) => TData): MetadataKey<TData>;
 /**
  * Defines the value of a {@link MetadataKey} for a given field.
  *
@@ -1378,7 +1464,7 @@ declare function metadata<TValue, TData, TPathKind extends PathKind = PathKind.R
  * @category logic
  * @experimental 21.0.0
  */
-declare function metadata<TValue, TData, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, key: MetadataKey<TData>, factory: (ctx: FieldContext<TValue, TPathKind>) => TData): MetadataKey<TData>;
+declare function metadata<TValue, TData, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, key: MetadataKey<TData>, factory: (ctx: FieldContext<TValue, TPathKind>) => TData): MetadataKey<TData>;
 
 /** Represents a result that should be ignored because its predicate indicates it is not active. */
 declare const IGNORED: unique symbol;
@@ -1393,7 +1479,7 @@ interface Predicate {
      * The path which this predicate was created for. This is used to determine the correct
      * `FieldContext` to pass to the predicate function.
      */
-    readonly path: FieldPath<any>;
+    readonly path: SchemaPath<any>;
 }
 /**
  * Represents a predicate that is bound to a particular depth in the field tree. This is needed for
@@ -1492,11 +1578,11 @@ declare class LogicContainer {
     /** Logic that determines if the field is read-only. */
     readonly readonly: BooleanOrLogic;
     /** Logic that produces synchronous validation errors for the field. */
-    readonly syncErrors: ArrayMergeIgnoreLogic<ValidationErrorWithField, null>;
+    readonly syncErrors: ArrayMergeIgnoreLogic<ValidationError.WithField, null>;
     /** Logic that produces synchronous validation errors for the field's subtree. */
-    readonly syncTreeErrors: ArrayMergeIgnoreLogic<ValidationErrorWithField, null>;
+    readonly syncTreeErrors: ArrayMergeIgnoreLogic<ValidationError.WithField, null>;
     /** Logic that produces asynchronous validation results (errors or 'pending'). */
-    readonly asyncErrors: ArrayMergeIgnoreLogic<ValidationErrorWithField | 'pending', null>;
+    readonly asyncErrors: ArrayMergeIgnoreLogic<ValidationError.WithField | 'pending', null>;
     /** 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. */
@@ -1524,7 +1610,7 @@ declare class LogicContainer {
      * @param key The `AggregateMetadataKey` for which to get the logic.
      * @returns The `AbstractLogic` associated with the key.
      */
-    getAggregateMetadata<T>(key: AggregateMetadataKey<unknown, T>): 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.
@@ -1609,10 +1695,10 @@ declare class LogicNodeBuilder extends AbstractLogicNodeBuilder {
     addHiddenRule(logic: LogicFn<any, boolean>): void;
     addDisabledReasonRule(logic: LogicFn<any, DisabledReason | undefined>): void;
     addReadonlyRule(logic: LogicFn<any, boolean>): void;
-    addSyncErrorRule(logic: LogicFn<any, ValidationResult<ValidationErrorWithField>>): void;
-    addSyncTreeErrorRule(logic: LogicFn<any, ValidationResult<ValidationErrorWithField>>): void;
-    addAsyncErrorRule(logic: LogicFn<any, AsyncValidationResult<ValidationErrorWithField>>): void;
-    addAggregateMetadataRule<T>(key: AggregateMetadataKey<unknown, T>, logic: LogicFn<any, T>): void;
+    addSyncErrorRule(logic: LogicFn<any, ValidationResult<ValidationError.WithField>>): void;
+    addSyncTreeErrorRule(logic: LogicFn<any, ValidationResult<ValidationError.WithField>>): void;
+    addAsyncErrorRule(logic: LogicFn<any, AsyncValidationResult<ValidationError.WithField>>): 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;
@@ -1705,7 +1791,7 @@ declare class FieldPathNode {
     /**
      * A proxy that wraps the path node, allowing navigation to its child paths via property access.
      */
-    readonly fieldPathProxy: FieldPath<any>;
+    readonly fieldPathProxy: SchemaPath<any>;
     /**
      * For a root path node this will contain the root logic builder. For non-root nodes,
      * they determine their logic builder from their parent so this is undefined.
@@ -1720,10 +1806,6 @@ declare class FieldPathNode {
     keyInParent: PropertyKey | undefined);
     /** The logic builder used to accumulate logic on this path node. */
     get builder(): LogicNodeBuilder;
-    /**
-     * Gets the special path node containing the per-element logic that applies to *all* children paths.
-     */
-    get element(): FieldPathNode;
     /**
      * Gets the path node for the given child property key.
      * Child paths are created automatically on first access if they do not exist already.
@@ -1736,7 +1818,7 @@ declare class FieldPathNode {
      */
     mergeIn(other: SchemaImpl, predicate?: Predicate): void;
     /** Extracts the underlying path node from the given path proxy. */
-    static unwrapFieldPath(formPath: FieldPath<unknown>): FieldPathNode;
+    static unwrapFieldPath(formPath: SchemaPath<unknown, SchemaPathRules>): FieldPathNode;
     /** Creates a new root path node to be passed in to a schema function. */
     static newRoot(): FieldPathNode;
 }
@@ -1842,6 +1924,7 @@ declare class FieldNodeState {
      */
     readonly hidden: Signal<boolean>;
     readonly name: Signal<string>;
+    debouncer(): Promise<void> | void;
     /** Whether this field is considered non-interactive.
      *
      * A field is considered non-interactive if one of the following is true:
@@ -1863,7 +1946,7 @@ declare class FieldSubmitState {
      */
     readonly selfSubmitting: WritableSignal<boolean>;
     /** Server errors that are associated with this field. */
-    readonly serverErrors: WritableSignal<readonly ValidationErrorWithField[]>;
+    readonly serverErrors: WritableSignal<readonly ValidationError.WithField[]>;
     constructor(node: FieldNode);
     /**
      * Whether this form is currently in the process of being submitted.
@@ -1877,14 +1960,14 @@ interface ValidationState {
      * The full set of synchronous tree errors visible to this field. This includes ones that are
      * targeted at a descendant field rather than at this field.
      */
-    rawSyncTreeErrors: Signal<ValidationErrorWithField[]>;
+    rawSyncTreeErrors: Signal<ValidationError.WithField[]>;
     /**
      * The full set of synchronous errors for this field, including synchronous tree errors and server
      * errors. Server errors are considered "synchronous" because they are imperatively added. From
      * the perspective of the field state they are either there or not, they are never in a pending
      * state.
      */
-    syncErrors: Signal<ValidationErrorWithField[]>;
+    syncErrors: Signal<ValidationError.WithField[]>;
     /**
      * Whether the field is considered valid according solely to its synchronous validators.
      * Errors resulting from a previous submit attempt are also considered for this state.
@@ -1895,21 +1978,21 @@ interface ValidationState {
      * targeted at a descendant field rather than at this field, as well as sentinel 'pending' values
      * indicating that the validator is still running and an error could still occur.
      */
-    rawAsyncErrors: Signal<(ValidationErrorWithField | 'pending')[]>;
+    rawAsyncErrors: Signal<(ValidationError.WithField | 'pending')[]>;
     /**
      * The asynchronous tree errors visible to this field that are specifically targeted at this field
      * rather than a descendant. This also includes all 'pending' sentinel values, since those could
      * theoretically result in errors for this field.
      */
-    asyncErrors: Signal<(ValidationErrorWithField | 'pending')[]>;
+    asyncErrors: Signal<(ValidationError.WithField | 'pending')[]>;
     /**
      * The combined set of all errors that currently apply to this field.
      */
-    errors: Signal<ValidationErrorWithField[]>;
+    errors: Signal<ValidationError.WithField[]>;
     /**
      * The combined set of all errors that currently apply to this field and its descendants.
      */
-    errorSummary: Signal<ValidationErrorWithField[]>;
+    errorSummary: Signal<ValidationError.WithField[]>;
     /**
      * Whether this field has any asynchronous validators still pending.
      */
@@ -1980,19 +2063,26 @@ declare class FieldNode implements FieldState<unknown> {
     readonly metadataState: FieldMetadataState;
     readonly nodeState: FieldNodeState;
     readonly submitState: FieldSubmitState;
-    private _context;
     readonly fieldAdapter: FieldAdapter;
+    private _context;
     get context(): FieldContext<unknown>;
     /**
      * Proxy to this node which allows navigation of the form graph below it.
      */
     readonly fieldProxy: FieldTree<any>;
     constructor(options: FieldNodeOptions);
+    /**
+     * The most recent promise returned by the debouncer, or `undefined` if no debounce is active.
+     * This is used to ensure that only the most recent debounce operation updates the field's value.
+     */
+    private readonly pendingSync;
     get logicNode(): LogicNode;
     get value(): WritableSignal<unknown>;
+    private _controlValue;
+    get controlValue(): Signal<unknown>;
     get keyInParent(): Signal<string | number>;
-    get errors(): Signal<ValidationErrorWithField[]>;
-    get errorSummary(): Signal<ValidationErrorWithField[]>;
+    get errors(): Signal<ValidationError.WithField[]>;
+    get errorSummary(): Signal<ValidationError.WithField[]>;
     get pending(): Signal<boolean>;
     get valid(): Signal<boolean>;
     get invalid(): Signal<boolean>;
@@ -2029,6 +2119,26 @@ declare class FieldNode implements FieldState<unknown> {
      * Note this does not change the data model, which can be reset directly if desired.
      */
     reset(): void;
+    /**
+     * Sets the control value of the field. This value may be debounced before it is synchronized with
+     * the field's {@link value} signal, depending on the debounce configuration.
+     */
+    setControlValue(newValue: unknown): void;
+    /**
+     * Synchronizes the {@link controlValue} with the {@link value} signal immediately.
+     *
+     * This also clears any pending debounce operations.
+     */
+    private sync;
+    /**
+     * Initiates a debounced {@link sync}.
+     *
+     * If a debouncer is configured, the synchronization will occur after the debouncer. If no
+     * debouncer is configured, the synchronization happens immediately. If a new
+     * {@link setControlValue} call occurs while a debounce is pending, the previous debounce
+     * operation is ignored in favor of the new one.
+     */
+    private debounceSync;
     /**
      * Creates a new root field node for a new form.
      */
@@ -2077,7 +2187,7 @@ declare abstract class FieldNodeStructure {
     /** The root field that this field descends from. */
     abstract readonly root: FieldNode;
     /** The list of property keys to follow to get from the `root` to this field. */
-    abstract readonly pathKeys: Signal<readonly PropertyKey[]>;
+    abstract readonly pathKeys: Signal<readonly string[]>;
     /** The parent field of this field. */
     abstract readonly parent: FieldNode | undefined;
     /** Added to array elements for tracking purposes. */
@@ -2104,7 +2214,7 @@ declare class RootFieldNodeStructure extends FieldNodeStructure {
     readonly value: WritableSignal<unknown>;
     get parent(): undefined;
     get root(): FieldNode;
-    get pathKeys(): Signal<readonly PropertyKey[]>;
+    get pathKeys(): Signal<readonly string[]>;
     get keyInParent(): Signal<string>;
     readonly childrenMap: Signal<Map<TrackingKey, FieldNode> | undefined>;
     /**
@@ -2126,7 +2236,7 @@ declare class RootFieldNodeStructure extends FieldNodeStructure {
 declare class ChildFieldNodeStructure extends FieldNodeStructure {
     readonly parent: ParentFieldNode;
     readonly root: FieldNode;
-    readonly pathKeys: Signal<readonly PropertyKey[]>;
+    readonly pathKeys: Signal<readonly string[]>;
     readonly keyInParent: Signal<string>;
     readonly value: WritableSignal<unknown>;
     readonly childrenMap: Signal<Map<TrackingKey, FieldNode> | undefined>;
@@ -2298,12 +2408,12 @@ interface FormOptions {
  * structure will match the shape of the model and any changes to the form data will be written to
  * the model.
  * @return A `FieldTree` representing a form around the data model.
- * @template TValue The type of the data model.
+ * @template TModel The type of the data model.
  *
  * @category structure
  * @experimental 21.0.0
  */
-declare function form<TValue>(model: WritableSignal<TValue>): FieldTree<TValue>;
+declare function form<TModel>(model: WritableSignal<TModel>): FieldTree<TModel>;
 /**
  * Creates a form wrapped around the given model data. A form is represented as simply a `FieldTree`
  * of the model data.
@@ -2349,7 +2459,7 @@ declare function form<TValue>(model: WritableSignal<TValue>): FieldTree<TValue>;
  * @category structure
  * @experimental 21.0.0
  */
-declare function form<TValue>(model: WritableSignal<TValue>, schemaOrOptions: SchemaOrSchemaFn<TValue> | FormOptions): FieldTree<TValue>;
+declare function form<TModel>(model: WritableSignal<TModel>, schemaOrOptions: SchemaOrSchemaFn<TModel> | FormOptions): FieldTree<TModel>;
 /**
  * Creates a form wrapped around the given model data. A form is represented as simply a `FieldTree`
  * of the model data.
@@ -2375,7 +2485,7 @@ declare function form<TValue>(model: WritableSignal<TValue>, schemaOrOptions: Sc
  * ```
  * const nameForm = form(signal({first: '', last: ''}), (name) => {
  *   required(name.first);
- *   error(name.last, ({value}) => !/^[a-z]+$/i.test(value()), 'Alphabet characters only');
+ *   validate(name.last, ({value}) => !/^[a-z]+$/i.test(value()) ? customError({kind: 'alphabet-only'}) : undefined);
  * });
  * nameForm().valid(); // false
  * nameForm().value.set({first: 'John', last: 'Doe'});
@@ -2388,12 +2498,12 @@ declare function form<TValue>(model: WritableSignal<TValue>, schemaOrOptions: Sc
  * @param schema A schema or a function used to specify logic for the form (e.g. validation, disabled fields, etc.)
  * @param options The form options
  * @return A `FieldTree` representing a form around the data model.
- * @template TValue The type of the data model.
+ * @template TModel The type of the data model.
  *
  * @category structure
  * @experimental 21.0.0
  */
-declare function form<TValue>(model: WritableSignal<TValue>, schema: SchemaOrSchemaFn<TValue>, options: FormOptions): FieldTree<TValue>;
+declare function form<TModel>(model: WritableSignal<TModel>, schema: SchemaOrSchemaFn<TModel>, options: FormOptions): FieldTree<TModel>;
 /**
  * Applies a schema to each item of an array.
  *
@@ -2408,22 +2518,6 @@ declare function form<TValue>(model: WritableSignal<TValue>, schema: SchemaOrSch
  * });
  * ```
  *
- * When binding logic to the array items, the `FieldTree` for the array item is passed as an
- * additional argument. This can be used to reference other properties on the item.
- *
- * @example
- * ```
- * const namesForm = form(signal([{first: '', last: ''}]), (names) => {
- *   applyEach(names, (name) => {
- *     error(
- *       name.last,
- *       (value, nameField) => value === nameField.first().value(),
- *       'Last name must be different than first name',
- *     );
- *   });
- * });
- * ```
- *
  * @param path The target path for an array field whose items the schema will be applied to.
  * @param schema A schema for an element of the array, or function that binds logic to an
  * element of the array.
@@ -2432,7 +2526,8 @@ declare function form<TValue>(model: WritableSignal<TValue>, schema: SchemaOrSch
  * @category structure
  * @experimental 21.0.0
  */
-declare function applyEach<TValue>(path: FieldPath<TValue[]>, schema: NoInfer<SchemaOrSchemaFn<TValue, PathKind.Item>>): void;
+declare function applyEach<TValue extends ReadonlyArray<any>>(path: SchemaPath<TValue>, schema: NoInfer<SchemaOrSchemaFn<TValue[number], PathKind.Item>>): void;
+declare function applyEach<TValue extends Object>(path: SchemaPath<TValue>, schema: NoInfer<SchemaOrSchemaFn<ItemType<TValue>, PathKind.Child>>): void;
 /**
  * Applies a predefined schema to a given `FieldPath`.
  *
@@ -2454,7 +2549,7 @@ declare function applyEach<TValue>(path: FieldPath<TValue[]>, schema: NoInfer<Sc
  * @category structure
  * @experimental 21.0.0
  */
-declare function apply<TValue>(path: FieldPath<TValue>, schema: NoInfer<SchemaOrSchemaFn<TValue>>): void;
+declare function apply<TValue>(path: SchemaPath<TValue>, schema: NoInfer<SchemaOrSchemaFn<TValue>>): void;
 /**
  * Conditionally applies a predefined schema to a given `FieldPath`.
  *
@@ -2466,7 +2561,7 @@ declare function apply<TValue>(path: FieldPath<TValue>, schema: NoInfer<SchemaOr
  * @category structure
  * @experimental 21.0.0
  */
-declare function applyWhen<TValue>(path: FieldPath<TValue>, logic: LogicFn<TValue, boolean>, schema: NoInfer<SchemaOrSchemaFn<TValue>>): void;
+declare function applyWhen<TValue>(path: SchemaPath<TValue>, logic: LogicFn<TValue, boolean>, schema: NoInfer<SchemaOrSchemaFn<TValue>>): void;
 /**
  * Conditionally applies a predefined schema to a given `FieldPath`.
  *
@@ -2480,7 +2575,7 @@ declare function applyWhen<TValue>(path: FieldPath<TValue>, logic: LogicFn<TValu
  * @category structure
  * @experimental 21.0.0
  */
-declare function applyWhenValue<TValue, TNarrowed extends TValue>(path: FieldPath<TValue>, predicate: (value: TValue) => value is TNarrowed, schema: SchemaOrSchemaFn<TNarrowed>): void;
+declare function applyWhenValue<TValue, TNarrowed extends TValue>(path: SchemaPath<TValue>, predicate: (value: TValue) => value is TNarrowed, schema: SchemaOrSchemaFn<TNarrowed>): void;
 /**
  * Conditionally applies a predefined schema to a given `FieldPath`.
  *
@@ -2493,7 +2588,7 @@ declare function applyWhenValue<TValue, TNarrowed extends TValue>(path: FieldPat
  * @category structure
  * @experimental 21.0.0
  */
-declare function applyWhenValue<TValue>(path: FieldPath<TValue>, predicate: (value: TValue) => boolean, schema: NoInfer<SchemaOrSchemaFn<TValue>>): void;
+declare function applyWhenValue<TValue>(path: SchemaPath<TValue>, predicate: (value: TValue) => boolean, schema: NoInfer<SchemaOrSchemaFn<TValue>>): void;
 /**
  * Submits a given `FieldTree` using the given action function and applies any server errors
  * resulting from the action to the field. Server errors returned by the `action` will be integrated
@@ -2523,12 +2618,12 @@ declare function applyWhenValue<TValue>(path: FieldPath<TValue>, predicate: (val
  * @param form The field to submit.
  * @param action An asynchronous action used to submit the field. The action may return server
  * errors.
- * @template TValue The data type of the field being submitted.
+ * @template TModel The data type of the field being submitted.
  *
  * @category submission
  * @experimental 21.0.0
  */
-declare function submit<TValue>(form: FieldTree<TValue>, action: (form: FieldTree<TValue>) => Promise<TreeValidationResult>): Promise<void>;
+declare function submit<TModel>(form: FieldTree<TModel>, action: (form: FieldTree<TModel>) => Promise<TreeValidationResult>): Promise<void>;
 /**
  * Creates a `Schema` that adds logic rules to a form.
  * @param fn A **non-reactive** function that sets up reactive logic rules for the form.
@@ -2573,7 +2668,7 @@ type BaseValidatorConfig<TValue, TPathKind extends PathKind = PathKind.Root> = {
  * @category validation
  * @experimental 21.0.0
  */
-declare function email<TPathKind extends PathKind = PathKind.Root>(path: FieldPath<string, TPathKind>, config?: BaseValidatorConfig<string, TPathKind>): void;
+declare function email<TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<string, SchemaPathRules.Supported, TPathKind>, config?: BaseValidatorConfig<string, TPathKind>): void;
 
 /**
  * Binds a validator to the given path that requires the value to be less than or equal to the
@@ -2591,7 +2686,7 @@ declare function email<TPathKind extends PathKind = PathKind.Root>(path: FieldPa
  * @category validation
  * @experimental 21.0.0
  */
-declare function max<TPathKind extends PathKind = PathKind.Root>(path: FieldPath<number, TPathKind>, maxValue: number | LogicFn<number, number | undefined, TPathKind>, config?: BaseValidatorConfig<number, TPathKind>): void;
+declare function max<TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<number, SchemaPathRules.Supported, TPathKind>, maxValue: number | LogicFn<number, number | undefined, TPathKind>, config?: BaseValidatorConfig<number, TPathKind>): void;
 
 /**
  * Binds a validator to the given path that requires the length of the value to be less than or
@@ -2610,7 +2705,7 @@ declare function max<TPathKind extends PathKind = PathKind.Root>(path: FieldPath
  * @category validation
  * @experimental 21.0.0
  */
-declare function maxLength<TValue extends ValueWithLengthOrSize, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, maxLength: number | LogicFn<TValue, number | undefined, TPathKind>, config?: BaseValidatorConfig<TValue, TPathKind>): void;
+declare function maxLength<TValue extends ValueWithLengthOrSize, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, maxLength: number | LogicFn<TValue, number | undefined, TPathKind>, config?: BaseValidatorConfig<TValue, TPathKind>): void;
 
 /**
  * Binds a validator to the given path that requires the value to be greater than or equal to
@@ -2628,7 +2723,7 @@ declare function maxLength<TValue extends ValueWithLengthOrSize, TPathKind exten
  * @category validation
  * @experimental 21.0.0
  */
-declare function min<TPathKind extends PathKind = PathKind.Root>(path: FieldPath<number, TPathKind>, minValue: number | LogicFn<number, number | undefined, TPathKind>, config?: BaseValidatorConfig<number, TPathKind>): void;
+declare function min<TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<number, SchemaPathRules.Supported, TPathKind>, minValue: number | LogicFn<number, number | undefined, TPathKind>, config?: BaseValidatorConfig<number, TPathKind>): void;
 
 /**
  * Binds a validator to the given path that requires the length of the value to be greater than or
@@ -2647,7 +2742,7 @@ declare function min<TPathKind extends PathKind = PathKind.Root>(path: FieldPath
  * @category validation
  * @experimental 21.0.0
  */
-declare function minLength<TValue extends ValueWithLengthOrSize, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, minLength: number | LogicFn<TValue, number | undefined, TPathKind>, config?: BaseValidatorConfig<TValue, TPathKind>): void;
+declare function minLength<TValue extends ValueWithLengthOrSize, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, minLength: number | LogicFn<TValue, number | undefined, TPathKind>, config?: BaseValidatorConfig<TValue, TPathKind>): void;
 
 /**
  * Binds a validator to the given path that requires the value to match a specific regex pattern.
@@ -2664,7 +2759,7 @@ declare function minLength<TValue extends ValueWithLengthOrSize, TPathKind exten
  * @category validation
  * @experimental 21.0.0
  */
-declare function pattern<TPathKind extends PathKind = PathKind.Root>(path: FieldPath<string, TPathKind>, pattern: RegExp | LogicFn<string | undefined, RegExp | undefined, TPathKind>, config?: BaseValidatorConfig<string, TPathKind>): void;
+declare function pattern<TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<string, SchemaPathRules.Supported, TPathKind>, pattern: RegExp | LogicFn<string | undefined, RegExp | undefined, TPathKind>, config?: BaseValidatorConfig<string, TPathKind>): void;
 
 /**
  * Binds a validator to the given path that requires the value to be non-empty.
@@ -2683,7 +2778,7 @@ declare function pattern<TPathKind extends PathKind = PathKind.Root>(path: Field
  * @category validation
  * @experimental 21.0.0
  */
-declare function required<TValue, TPathKind extends PathKind = PathKind.Root>(path: FieldPath<TValue, TPathKind>, config?: BaseValidatorConfig<TValue, TPathKind> & {
+declare function required<TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, config?: BaseValidatorConfig<TValue, TPathKind> & {
     when?: NoInfer<LogicFn<TValue, boolean, TPathKind>>;
 }): void;
 
@@ -2719,7 +2814,7 @@ type IgnoreUnknownProperties<T> = T extends Record<PropertyKey, unknown> ? {
  * @category validation
  * @experimental 21.0.0
  */
-declare function validateStandardSchema<TSchema, TValue extends IgnoreUnknownProperties<TSchema>>(path: FieldPath<TValue>, schema: StandardSchemaV1<TSchema>): void;
+declare function validateStandardSchema<TSchema, TModel extends IgnoreUnknownProperties<TSchema>>(path: SchemaPath<TModel> & SchemaPathTree<TModel>, schema: StandardSchemaV1<TSchema>): void;
 
-export { AggregateMetadataKey, CustomValidationError, EmailValidationError, FIELD, Field, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MetadataKey, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PathKind, PatternValidationError, REQUIRED, RequiredValidationError, StandardSchemaValidationError, aggregateMetadata, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, createMetadataKey, customError, disabled, email, emailError, form, hidden, listMetadataKey, max, maxError, maxLength, maxLengthError, maxMetadataKey, metadata, min, minError, minLength, minLengthError, minMetadataKey, orMetadataKey, pattern, patternError, readonly, reducedMetadataKey, required, requiredError, schema, standardSchemaError, submit, validate, validateAsync, validateHttp, validateStandardSchema, validateTree };
-export type { AsyncValidationResult, AsyncValidatorOptions, ChildFieldContext, DisabledReason, FieldContext, FieldPath, FieldState, FieldTree, FieldValidator, FormCheckboxControl, FormOptions, FormUiControl, FormValueControl, HttpValidatorOptions, IgnoreUnknownProperties, ItemFieldContext, LogicFn, MapToErrorsFn, MaybeFieldPath, MaybeFieldTree, OneOrMany, ReadonlyArrayLike, RemoveStringIndexUnknownKey, RootFieldContext, Schema, SchemaFn, SchemaOrSchemaFn, Subfields, SubmittedStatus, TreeValidationResult, TreeValidator, ValidationError, ValidationErrorWithField, ValidationErrorWithOptionalField, ValidationErrorWithoutField, 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, aggregateMetadata, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, createMetadataKey, customError, debounce, disabled, email, emailError, form, hidden, listMetadataKey, max, maxError, maxLength, maxLengthError, maxMetadataKey, metadata, min, minError, minLength, minLengthError, minMetadataKey, orMetadataKey, pattern, patternError, readonly, reducedMetadataKey, required, requiredError, schema, standardSchemaError, submit, validate, validateAsync, validateHttp, validateStandardSchema, validateTree };
+export type { AsyncValidationResult, AsyncValidatorOptions, ChildFieldContext, CompatFieldState, CompatSchemaPath, Debouncer, DisabledReason, FieldContext, FieldState, FieldTree, FieldValidator, FormCheckboxControl, FormOptions, FormUiControl, FormValueControl, HttpValidatorOptions, IgnoreUnknownProperties, ItemFieldContext, ItemType, LogicFn, MapToErrorsFn, MaybeFieldTree, MaybeSchemaPathTree, OneOrMany, ReadonlyArrayLike, RemoveStringIndexUnknownKey, RootFieldContext, Schema, SchemaFn, SchemaOrSchemaFn, SchemaPath, SchemaPathTree, Subfields, SubmittedStatus, TreeValidationResult, TreeValidator, ValidationResult, ValidationSuccess, Validator, WithField, WithOptionalField, WithoutField };