@ng-forge/dynamic-forms 1.2.0-next.5 → 1.2.0-next.7

package/types/ng-forge-dynamic-forms-internal.d.ts

@@ -1,8 +1,8 @@
 import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
 import * as i0 from '@angular/core';
-import { Signal, Type, ResourceRef, ViewContainerRef, InjectionToken, WritableSignal, Injector, TemplateRef, PipeTransform, Resource } from '@angular/core';
+import { Signal, Type, ResourceRef, ViewContainerRef, InjectionToken, WritableSignal, Injector, TemplateRef, PipeTransform, Resource, Provider } from '@angular/core';
 import { Observable, OperatorFunction } from 'rxjs';
-import { FieldContext, TreeValidationResult, ValidationError as ValidationError$1, FieldTree, ReadonlyFieldState, LogicFn, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
+import { FieldContext, ValidationError as ValidationError$1, TreeValidationResult, FieldTree, ReadonlyFieldState, LogicFn, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
 import { FormSchema } from '@ng-forge/dynamic-forms/schema';
 
 type DynamicText = string | Observable<string> | Signal<string>;
@@ -480,12 +480,242 @@ interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowA
 declare function isRowField(field: FieldDef<any>): field is RowField;
 type RowComponent = FieldComponent<RowField<RowAllowedChildren[]>>;
 
+/**
+ * Custom validator function signature using Angular's public FieldContext API
+ *
+ * @template TValue The type of value stored in the field being validated
+ */
+type CustomValidator<TValue = unknown> = (ctx: FieldContext<TValue>, params?: Record<string, unknown>) => ValidationError$1 | ValidationError$1[] | null;
+/**
+ * Async custom validator configuration using Angular's resource-based API
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TParams The type of params passed to the resource
+ * @template TResult The type of result returned by the resource
+ */
+interface AsyncCustomValidator<TValue = unknown, TParams = unknown, TResult = unknown> {
+    /**
+     * Function that receives field context and returns resource params.
+     * Params will be tracked as a signal and trigger resource reload when changed.
+     */
+    readonly params: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => TParams;
+    /**
+     * Function that creates a ResourceRef from the params signal.
+     * The resource will be automatically managed by Angular's lifecycle.
+     */
+    readonly factory: (params: Signal<TParams | undefined>) => ResourceRef<TResult | undefined>;
+    /**
+     * Optional function to map successful resource result to validation errors.
+     * Return null if validation passes, or ValidationError/ValidationError[] if validation fails.
+     */
+    readonly onSuccess?: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
+    /**
+     * Optional error handler for resource errors (network failures, etc.).
+     * Return null to ignore the error, or ValidationError to display it to the user.
+     */
+    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
+}
+/** HTTP request configuration for validateHttp API */
+interface HttpResourceRequest {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    headers?: Record<string, string | string[]>;
+}
+/**
+ * HTTP-based validator configuration for Angular's validateHttp API
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TResult The type of HTTP response
+ */
+interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
+    /**
+     * Function that returns the HTTP request configuration.
+     * Can return:
+     * - `undefined` to skip validation (e.g., if field is empty)
+     * - `string` for simple GET requests (just the URL)
+     * - `HttpResourceRequest` for full control (method, body, headers)
+     */
+    readonly request: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => string | HttpResourceRequest | undefined;
+    /** REQUIRED function to map successful HTTP response to validation errors. */
+    readonly onSuccess: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
+    /**
+     * Optional error handler for HTTP errors (network failures, 4xx/5xx status codes).
+     * Return null to ignore the error, or ValidationError to display it to the user.
+     */
+    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
+}
+
+/** Mapping configuration for interpreting HTTP responses as validation results. */
+interface HttpValidationResponseMapping {
+    /** Expression evaluated with scope `{ response }`. Must evaluate to `true` (strict boolean) to be valid. */
+    validWhen: string;
+    /** Error kind returned when validation fails — maps to field-level `validationMessages` */
+    errorKind: string;
+    /**
+     * Parameters to include in the validation error for message interpolation.
+     * Map of parameter names to expressions evaluated against `{ response }`.
+     */
+    errorParams?: Record<string, string>;
+}
+
+/** Base configuration shared by all validators */
+interface BaseValidatorConfig {
+    /** Conditional logic for when validator applies */
+    when?: ConditionalExpression;
+}
+/** Built-in validator configuration (required, email, min, max, etc.) */
+interface BuiltInValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
+    /** Static value for the validator (e.g., min value, pattern) */
+    value?: number | string | RegExp;
+    /** Dynamic value expression that evaluates to validator parameter */
+    expression?: string;
+}
+/**
+ * Custom validator configuration using Angular's public FieldContext API.
+ * Returns ValidationError | ValidationError[] | null synchronously.
+ */
+interface CustomValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'custom';
+    /** Name of registered validator function (function-based pattern) */
+    functionName?: string;
+    /**
+     * Inline custom validator (code-only authoring).
+     * Mutually exclusive with `functionName`. NOT JSON-serializable.
+     */
+    fn?: CustomValidator;
+    /** Optional parameters to pass to validator function */
+    params?: Record<string, unknown>;
+    /** JavaScript expression to evaluate (expression-based pattern) */
+    expression?: string;
+    /** Error kind for expression-based validators - links to validationMessages */
+    kind?: string;
+    /**
+     * Parameters to include in error object for message interpolation (expression-based pattern)
+     * Map of parameter names to expressions that will be evaluated in the same context as the validation expression
+     */
+    errorParams?: Record<string, string>;
+}
+/**
+ * Shared fields for both branches of {@link AsyncValidatorConfig}.
+ *
+ * @internal
+ */
+interface AsyncValidatorConfigShared extends BaseValidatorConfig {
+    /** Validator type identifier. */
+    type: 'async';
+    /** Optional parameters to pass to validator function */
+    params?: Record<string, unknown>;
+}
+/**
+ * Async custom validator configuration using Angular's `validateAsync` API.
+ * Returns Observable<ValidationError | ValidationError[] | null>.
+ */
+type AsyncValidatorConfig = (AsyncValidatorConfigShared & {
+    /** Name of registered async validator function */
+    functionName: string;
+    /** Inline form is forbidden when `functionName` is set */
+    fn?: never;
+}) | (AsyncValidatorConfigShared & {
+    /** Inline async validator. Mutually exclusive with `functionName`. */
+    fn: AsyncCustomValidator;
+    /** Registered form is forbidden when `fn` is set */
+    functionName?: never;
+});
+/**
+ * Shared fields for both branches of {@link FunctionHttpValidatorConfig}.
+ *
+ * @internal
+ */
+interface FunctionHttpValidatorConfigShared extends BaseValidatorConfig {
+    /** Validator type identifier. */
+    type: 'http';
+    /** Optional parameters to pass to HTTP validator */
+    params?: Record<string, unknown>;
+}
+/** Function-based HTTP validator configuration. Uses Angular's `validateHttp` API. */
+type FunctionHttpValidatorConfig = (FunctionHttpValidatorConfigShared & {
+    /** Name of registered HTTP validator configuration */
+    functionName: string;
+    /** Inline form is forbidden when `functionName` is set */
+    fn?: never;
+}) | (FunctionHttpValidatorConfigShared & {
+    /** Inline HTTP validator. Mutually exclusive with `functionName`. */
+    fn: HttpCustomValidator;
+    /** Registered form is forbidden when `fn` is set */
+    functionName?: never;
+});
+/** Declarative HTTP validator configuration — fully JSON-serializable, no function registration required. */
+interface DeclarativeHttpValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'http';
+    /** HTTP request configuration with expression-based query params and body */
+    http: HttpRequestConfig;
+    /** Mapping that interprets the HTTP response as a validation result */
+    responseMapping: HttpValidationResponseMapping;
+}
+/**
+ * Configuration for signal forms validator functions that can be serialized from API.
+ * Discriminated union type for type-safe validator configuration.
+ */
+type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig;
+/** Type guard to distinguish function-based HTTP validators from declarative ones. */
+declare function isFunctionHttpValidator(config: FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig): config is FunctionHttpValidatorConfig;
+
+/**
+ * Re-export Angular's ValidationError for consistency
+ * This replaces our custom ValidationError interface
+ */
+type ValidationError = ValidationError$1;
+/**
+ * Resolves a validation message from the validation error, so error params
+ * (e.g. maxLength, min) can be passed to an i18n layer natively.
+ */
+type ValidationMessageResolver = (error: ValidationError) => DynamicText;
+/** A validation message: static or reactive text, or a function of the validation error. */
+type ValidationMessage = DynamicText | ValidationMessageResolver;
+interface ValidationMessages {
+    required?: ValidationMessage;
+    email?: ValidationMessage;
+    min?: ValidationMessage;
+    max?: ValidationMessage;
+    minLength?: ValidationMessage;
+    maxLength?: ValidationMessage;
+    pattern?: ValidationMessage;
+    [key: string]: ValidationMessage | undefined;
+}
+
+/**
+ * Tree-level validation for container fields (`group` / `array`).
+ *
+ * A validator here runs against the container's own subtree: `ctx.value()` is the group's
+ * object or the array's item list. Layout containers (`page`, `row`, `container`) flatten
+ * into their parent and have no schema path, so they are excluded.
+ */
+interface ContainerValidation {
+    /**
+     * Marks every descendant required. An inherited default, not a rule on the container —
+     * a descendant's own `required` wins, including `false`. Use `minLength` for array size.
+     */
+    readonly required?: boolean;
+    /** Validators applied to the container's own schema path. Gated by `validateWhenHidden`. */
+    readonly validators?: ValidatorConfig[];
+    /**
+     * Messages keyed by error `kind`. Rendered by the `field-errors` wrapper, attached
+     * automatically when the container declares `validators`.
+     */
+    readonly validationMessages?: ValidationMessages;
+}
+
 /**
  * Group field interface for creating logical field groupings that map to object values
  * Groups create nested form structures where child field values are collected into an object
  * This is a programmatic grouping only - users cannot customize this field type
  */
-interface GroupField<TFields extends readonly GroupAllowedChildren[] = readonly GroupAllowedChildren[]> extends FieldDef<never> {
+interface GroupField<TFields extends readonly GroupAllowedChildren[] = readonly GroupAllowedChildren[]> extends FieldDef<never>, ContainerValidation {
     type: 'group';
     readonly fields: TFields;
     /** Groups do not have a label property - they are logical containers only * */
@@ -573,7 +803,7 @@ type ArrayItemTemplate = readonly ArrayAllowedChildren[];
  */
 type ArrayItemDefinition = ArrayAllowedChildren | ArrayItemTemplate;
 /** Array field interface for creating dynamic field collections that map to array values. */
-interface ArrayField<TFields extends readonly ArrayItemDefinition[] = readonly ArrayItemDefinition[]> extends FieldDef<never> {
+interface ArrayField<TFields extends readonly ArrayItemDefinition[] = readonly ArrayItemDefinition[]> extends FieldDef<never>, ContainerValidation {
     type: 'array';
     /**
      * Array of item definitions. Each element defines one array item:
@@ -619,7 +849,7 @@ interface ArrayButtonConfig {
     readonly props?: Record<string, unknown>;
 }
 /** Simplified array field interface for common use cases. */
-interface SimplifiedArrayField extends FieldDef<never> {
+interface SimplifiedArrayField extends FieldDef<never>, ContainerValidation {
     type: 'array';
     /**
      * Template defining the structure of a single array item.
@@ -887,191 +1117,6 @@ type InferFormValue<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[
  */
 type InferFormModel<T, M = InferFormValue<T>> = M extends Record<string, unknown> ? M : Record<string, unknown>;
 
-/**
- * Custom validator function signature using Angular's public FieldContext API
- *
- * @template TValue The type of value stored in the field being validated
- */
-type CustomValidator<TValue = unknown> = (ctx: FieldContext<TValue>, params?: Record<string, unknown>) => ValidationError$1 | ValidationError$1[] | null;
-/**
- * Async custom validator configuration using Angular's resource-based API
- *
- * @template TValue The type of value stored in the field being validated
- * @template TParams The type of params passed to the resource
- * @template TResult The type of result returned by the resource
- */
-interface AsyncCustomValidator<TValue = unknown, TParams = unknown, TResult = unknown> {
-    /**
-     * Function that receives field context and returns resource params.
-     * Params will be tracked as a signal and trigger resource reload when changed.
-     */
-    readonly params: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => TParams;
-    /**
-     * Function that creates a ResourceRef from the params signal.
-     * The resource will be automatically managed by Angular's lifecycle.
-     */
-    readonly factory: (params: Signal<TParams | undefined>) => ResourceRef<TResult | undefined>;
-    /**
-     * Optional function to map successful resource result to validation errors.
-     * Return null if validation passes, or ValidationError/ValidationError[] if validation fails.
-     */
-    readonly onSuccess?: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
-    /**
-     * Optional error handler for resource errors (network failures, etc.).
-     * Return null to ignore the error, or ValidationError to display it to the user.
-     */
-    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
-}
-/** HTTP request configuration for validateHttp API */
-interface HttpResourceRequest {
-    url: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    body?: unknown;
-    headers?: Record<string, string | string[]>;
-}
-/**
- * HTTP-based validator configuration for Angular's validateHttp API
- *
- * @template TValue The type of value stored in the field being validated
- * @template TResult The type of HTTP response
- */
-interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
-    /**
-     * Function that returns the HTTP request configuration.
-     * Can return:
-     * - `undefined` to skip validation (e.g., if field is empty)
-     * - `string` for simple GET requests (just the URL)
-     * - `HttpResourceRequest` for full control (method, body, headers)
-     */
-    readonly request: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => string | HttpResourceRequest | undefined;
-    /** REQUIRED function to map successful HTTP response to validation errors. */
-    readonly onSuccess: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
-    /**
-     * Optional error handler for HTTP errors (network failures, 4xx/5xx status codes).
-     * Return null to ignore the error, or ValidationError to display it to the user.
-     */
-    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
-}
-
-/** Mapping configuration for interpreting HTTP responses as validation results. */
-interface HttpValidationResponseMapping {
-    /** Expression evaluated with scope `{ response }`. Must evaluate to `true` (strict boolean) to be valid. */
-    validWhen: string;
-    /** Error kind returned when validation fails — maps to field-level `validationMessages` */
-    errorKind: string;
-    /**
-     * Parameters to include in the validation error for message interpolation.
-     * Map of parameter names to expressions evaluated against `{ response }`.
-     */
-    errorParams?: Record<string, string>;
-}
-
-/** Base configuration shared by all validators */
-interface BaseValidatorConfig {
-    /** Conditional logic for when validator applies */
-    when?: ConditionalExpression;
-}
-/** Built-in validator configuration (required, email, min, max, etc.) */
-interface BuiltInValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
-    /** Static value for the validator (e.g., min value, pattern) */
-    value?: number | string | RegExp;
-    /** Dynamic value expression that evaluates to validator parameter */
-    expression?: string;
-}
-/**
- * Custom validator configuration using Angular's public FieldContext API.
- * Returns ValidationError | ValidationError[] | null synchronously.
- */
-interface CustomValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'custom';
-    /** Name of registered validator function (function-based pattern) */
-    functionName?: string;
-    /**
-     * Inline custom validator (code-only authoring).
-     * Mutually exclusive with `functionName`. NOT JSON-serializable.
-     */
-    fn?: CustomValidator;
-    /** Optional parameters to pass to validator function */
-    params?: Record<string, unknown>;
-    /** JavaScript expression to evaluate (expression-based pattern) */
-    expression?: string;
-    /** Error kind for expression-based validators - links to validationMessages */
-    kind?: string;
-    /**
-     * Parameters to include in error object for message interpolation (expression-based pattern)
-     * Map of parameter names to expressions that will be evaluated in the same context as the validation expression
-     */
-    errorParams?: Record<string, string>;
-}
-/**
- * Shared fields for both branches of {@link AsyncValidatorConfig}.
- *
- * @internal
- */
-interface AsyncValidatorConfigShared extends BaseValidatorConfig {
-    /** Validator type identifier. */
-    type: 'async';
-    /** Optional parameters to pass to validator function */
-    params?: Record<string, unknown>;
-}
-/**
- * Async custom validator configuration using Angular's `validateAsync` API.
- * Returns Observable<ValidationError | ValidationError[] | null>.
- */
-type AsyncValidatorConfig = (AsyncValidatorConfigShared & {
-    /** Name of registered async validator function */
-    functionName: string;
-    /** Inline form is forbidden when `functionName` is set */
-    fn?: never;
-}) | (AsyncValidatorConfigShared & {
-    /** Inline async validator. Mutually exclusive with `functionName`. */
-    fn: AsyncCustomValidator;
-    /** Registered form is forbidden when `fn` is set */
-    functionName?: never;
-});
-/**
- * Shared fields for both branches of {@link FunctionHttpValidatorConfig}.
- *
- * @internal
- */
-interface FunctionHttpValidatorConfigShared extends BaseValidatorConfig {
-    /** Validator type identifier. */
-    type: 'http';
-    /** Optional parameters to pass to HTTP validator */
-    params?: Record<string, unknown>;
-}
-/** Function-based HTTP validator configuration. Uses Angular's `validateHttp` API. */
-type FunctionHttpValidatorConfig = (FunctionHttpValidatorConfigShared & {
-    /** Name of registered HTTP validator configuration */
-    functionName: string;
-    /** Inline form is forbidden when `functionName` is set */
-    fn?: never;
-}) | (FunctionHttpValidatorConfigShared & {
-    /** Inline HTTP validator. Mutually exclusive with `functionName`. */
-    fn: HttpCustomValidator;
-    /** Registered form is forbidden when `fn` is set */
-    functionName?: never;
-});
-/** Declarative HTTP validator configuration — fully JSON-serializable, no function registration required. */
-interface DeclarativeHttpValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'http';
-    /** HTTP request configuration with expression-based query params and body */
-    http: HttpRequestConfig;
-    /** Mapping that interprets the HTTP response as a validation result */
-    responseMapping: HttpValidationResponseMapping;
-}
-/**
- * Configuration for signal forms validator functions that can be serialized from API.
- * Discriminated union type for type-safe validator configuration.
- */
-type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig;
-/** Type guard to distinguish function-based HTTP validators from declarative ones. */
-declare function isFunctionHttpValidator(config: FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig): config is FunctionHttpValidatorConfig;
-
 /** Special form-state conditions for button disabled logic. */
 type FormStateCondition = 
 /** True when form.valid() === false */
@@ -1454,29 +1499,6 @@ interface SchemaDefinition {
     subSchemas?: SchemaApplicationConfig[];
 }
 
-/**
- * Re-export Angular's ValidationError for consistency
- * This replaces our custom ValidationError interface
- */
-type ValidationError = ValidationError$1;
-/**
- * Resolves a validation message from the validation error, so error params
- * (e.g. maxLength, min) can be passed to an i18n layer natively.
- */
-type ValidationMessageResolver = (error: ValidationError) => DynamicText;
-/** A validation message: static or reactive text, or a function of the validation error. */
-type ValidationMessage = DynamicText | ValidationMessageResolver;
-interface ValidationMessages {
-    required?: ValidationMessage;
-    email?: ValidationMessage;
-    min?: ValidationMessage;
-    max?: ValidationMessage;
-    minLength?: ValidationMessage;
-    maxLength?: ValidationMessage;
-    pattern?: ValidationMessage;
-    [key: string]: ValidationMessage | undefined;
-}
-
 /**
  * The result type for submission actions.
  * Can be either a Promise or an Observable.
@@ -1601,11 +1623,11 @@ interface FormOptions {
      */
     initialPage?: number | InitialPageConfig;
     /**
-     * For paged forms: how many pages on each side of the current page are eagerly
-     * mounted (the "preload window"). Pages outside the window render a lightweight
-     * placeholder and mount when navigation brings them into range.
+     * For paged forms: how many pages on each side of the current page are mounted
+     * during idle time (the "preload window"). The active page renders directly;
+     * pages outside the window remain lightweight placeholders.
      *
-     * `0` mounts only the current page; `1` mounts ±1 for flicker-free sequential
+     * `0` mounts only the current page; `1` preloads ±1 on idle for flicker-free sequential
      * navigation; higher values pre-warm more pages for jump navigation at the cost
      * of more initial DOM + change detection.
      *
@@ -1850,6 +1872,24 @@ interface RowWrapper {
     readonly type: 'row';
 }
 
+/**
+ * Renders the wrapped field's validation errors, for a leaf or a container.
+ *
+ * On a container it is the only thing that can render the message — a `group` / `array`
+ * has no adapter field component — so it is appended automatically when the container
+ * declares `validators`. On a leaf it is opt-in: adding it takes error rendering over
+ * from the field component, which suppresses its own via `FIELD_ERROR_DISPLAY`.
+ *
+ * To restyle it, register a `WrapperTypeDefinition` with the same
+ * `wrapperName: 'field-errors'` — the later registration wins, so an adapter or an app
+ * can swap in its own component without touching config.
+ */
+interface FieldErrorsWrapper {
+    readonly type: 'field-errors';
+    /** Messages keyed by error `kind`. Containers forward their own `validationMessages`. */
+    readonly validationMessages?: ValidationMessages;
+}
+
 /** Container fields registry - augment this interface to add custom container fields */
 interface FieldRegistryContainers {
     page: PageField;
@@ -1867,6 +1907,7 @@ interface FieldRegistryLeaves {
 interface FieldRegistryWrappers {
     css: CssWrapper;
     row: RowWrapper;
+    'field-errors': FieldErrorsWrapper;
 }
 /**
  * Global interface for dynamic form field definitions with categorization
@@ -1945,6 +1986,12 @@ interface WrapperTypeDefinition<T extends WrapperConfig = WrapperConfig> {
     loadComponent: LazyComponentLoader;
     /** Field types this wrapper should auto-apply to. */
     types?: readonly string[];
+    /**
+     * Declares that this wrapper renders the wrapped field's errors, so the default
+     * `field-errors` wrapper is not appended next to it. Needed here as well as via
+     * `provideFieldErrorDisplay`: the chain resolves before any component exists to ask.
+     */
+    rendersFieldErrors?: boolean;
 }
 /** Type guard for WrapperTypeDefinition. */
 declare function isWrapperTypeDefinition(value: unknown): value is WrapperTypeDefinition;
@@ -1970,7 +2017,7 @@ interface FieldWrapper {
     readonly fieldComponent: Signal<ViewContainerRef>;
 }
 /** Injection token for the wrapper type registry. */
-declare const WRAPPER_REGISTRY: InjectionToken<Map<string, WrapperTypeDefinition<_ng_forge_dynamic_forms_internal.RowWrapper | _ng_forge_dynamic_forms_internal.CssWrapper>>>;
+declare const WRAPPER_REGISTRY: InjectionToken<Map<string, WrapperTypeDefinition<_ng_forge_dynamic_forms_internal.RowWrapper | _ng_forge_dynamic_forms_internal.CssWrapper | _ng_forge_dynamic_forms_internal.FieldErrorsWrapper>>>;
 /** Component cache for loaded wrapper components. */
 declare const WRAPPER_COMPONENT_CACHE: InjectionToken<Map<string, Type<unknown>>>;
 /**
@@ -2948,8 +2995,122 @@ declare class RootFormRegistryService {
     constructor(formValue: Signal<Record<string, unknown>>, rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>);
 }
 
-declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
-declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
+/** Resolved validation error with interpolated message */
+interface ResolvedError {
+    kind: string;
+    message: string;
+}
+/**
+ * Factory function that creates a signal of resolved validation errors
+ * Handles async resolution of DynamicText validation messages
+ *
+ * @param field - Signal containing the FieldTree, or `undefined` before it
+ *   exists (containers resolve their node lazily from the parent tree)
+ * @param validationMessages - Signal containing custom field-level validation messages
+ * @param defaultValidationMessages - Signal containing default validation messages (fallback)
+ * @param injector - Optional injector for DynamicText resolution
+ * @returns Signal<ResolvedError[]> - Reactively resolved error messages
+ */
+declare function createResolvedErrorsSignal<T>(field: Signal<FieldTree<T> | undefined>, validationMessages: Signal<ValidationMessages | undefined>, defaultValidationMessages?: Signal<ValidationMessages | undefined>, injector?: Injector): Signal<ResolvedError[]>;
+
+/** A wrapper's claim to render errors, scoped to the one field key it wraps. */
+interface FieldErrorDisplayClaim {
+    /** Key of the field whose errors this wrapper renders; `undefined` before inputs bind. */
+    readonly claimedKey: Signal<string | undefined>;
+}
+/**
+ * Marks that a wrapper is rendering a field's errors, so that field's component stops
+ * rendering its own and the message appears once.
+ *
+ * The claim carries a key because a wrapper's providers reach every descendant: a wrapper
+ * around an `array` would otherwise silence the errors of every input inside it. A field
+ * suppresses its own rendering only when the claimed key is its own.
+ *
+ * Not `multi` — element injectors shadow rather than merge, so a nested claim would hide
+ * the outer one regardless.
+ */
+declare const FIELD_ERROR_DISPLAY: InjectionToken<FieldErrorDisplayClaim>;
+/** The error surface a wrapper gets, mirroring what `NgForgeField` exposes to field components. */
+interface FieldErrors {
+    /** Every resolved error, regardless of whether it should be shown yet. */
+    readonly errors: Signal<ResolvedError[]>;
+    /** Whether errors are ready to show — invalid, touched, and non-empty. */
+    readonly showErrors: Signal<boolean>;
+    /** `errors()` gated by `showErrors()`. This is what a template should render. */
+    readonly errorsToDisplay: Signal<ResolvedError[]>;
+    /** `{key}-error`, for wiring `aria-describedby` on the wrapped control. */
+    readonly errorId: Signal<string>;
+}
+interface FieldErrorsOptions {
+    /** The wrapper's `fieldInputs` input. */
+    readonly fieldInputs: Signal<WrapperFieldInputs | undefined>;
+    /** Overrides the messages in `fieldInputs` — containers pass their own. */
+    readonly validationMessages?: Signal<ValidationMessages | undefined>;
+    /** Defaults to the current injection context. */
+    readonly injector?: Injector;
+}
+/**
+ * Resolves the wrapped field's errors for a wrapper component, for a leaf or a container.
+ *
+ * A wrapper cannot `inject(NgForgeField)` — the chain is built before the field component
+ * exists — so this reads the same information out of the `fieldInputs` bag it already has.
+ * A leaf carries its own `field`; a container has none, so its node is resolved by key
+ * against the parent tree in `FIELD_SIGNAL_CONTEXT`.
+ *
+ * Must be called in an injection context.
+ */
+declare function injectFieldErrors(options: FieldErrorsOptions): FieldErrors;
+
+/** The error to raise, minus the `fieldTree` that {@link rowError} fills in. */
+interface RowErrorSpec {
+    /** Error kind, matched against `validationMessages`. */
+    readonly kind: string;
+    /**
+     * Message shown for this error. A row-targeted error needs its own, because the
+     * container's `validationMessages` are keyed to the container, not to the child the
+     * error moves to.
+     */
+    readonly message?: string;
+    readonly [param: string]: unknown;
+}
+/**
+ * Targets a validation error at one field of one row, from a validator declared on the
+ * array (issue #568).
+ *
+ * A container validator sees the whole item list, which is what makes per-row rules
+ * expressible at all — but one message for the list cannot say which row is wrong.
+ * Returning the result of this helper puts the error on that row's own input, where the
+ * adapter renders it like any other field error.
+ *
+ * ```typescript
+ * const periodOrder: CustomValidator = (ctx) => {
+ *   const rows = (ctx.value() ?? []) as { from?: string; to?: string }[];
+ *   return rows.flatMap((row, i) =>
+ *     row.from && row.to && row.to < row.from
+ *       ? [rowError(ctx, i, 'to', { kind: 'periodOrder', message: 'The end must not be before the start.' })]
+ *       : [],
+ *   );
+ * };
+ * ```
+ *
+ * Returns the error untargeted when the row or field cannot be resolved, so it still
+ * surfaces on the container rather than vanishing.
+ */
+declare function rowError(ctx: FieldContext<unknown>, index: number, key: string, error: RowErrorSpec): ValidationError$1;
+
+/**
+ * Computed signal that determines if errors should be displayed.
+ * Based on field's invalid, touched, and error count.
+ *
+ * @param field - Signal containing the FieldTree, or `undefined` before it exists
+ * @returns Signal<boolean> - True if errors should be displayed
+ */
+declare function shouldShowErrors<T>(field: Signal<FieldTree<T> | undefined>): Signal<boolean>;
+
+/** `field` = `validate()`; `tree` = `validateTree()`, which re-homes errors carrying a `fieldTree`. */
+type ValidatorAttachment = 'field' | 'tree';
+declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>, attachment?: ValidatorAttachment): void;
+declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>, attachment?: ValidatorAttachment): void;
 
 /**
  * Create a dynamic value function from an expression string.
@@ -3666,6 +3827,11 @@ declare function memoize<TFunc extends (...args: any[]) => any>(fn: TFunc, resol
  * @returns Fields as array
  */
 declare function normalizeFieldsArray<T>(fields: readonly T[] | Record<string, T>): T[];
+/**
+ * {@link getChangedKeys} restricted to `keys`. Callers that only care about a handful of
+ * paths avoid diffing an entire form value on every change.
+ */
+declare function getChangedKeysWithin(previous: Record<string, unknown> | null | undefined, current: Record<string, unknown> | null | undefined, keys: ReadonlySet<string>): Set<string>;
 /**
  * Gets the keys that differ between two objects.
  *
@@ -3685,5 +3851,46 @@ declare function assertNever(value: never): never;
  */
 declare function withPreviousValue<T>(input: Resource<T>): Resource<T>;
 
-export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAddonActionRegistry, createDebouncedLogicFunction, createDefaultDerivationLogConfig, createDynamicValueFunction, createFieldValueProxy, createFormFieldStateMap, createFormStateLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldSignalContext, injectFieldsSupportingAddons, injectNonFieldEvaluationContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, runPresetAction, setupInitializationTracking, shouldLog, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
-export type { ASTNode, AddonActionContext, AddonActionHandler, AddonActionPreset, AddonShapeValidator, AddonSlot, AddonTypeDefinition, AddonTypeRegistryRef, AddonTypeSchema, AndCondition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayComponent, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemDefinition, ArrayItemTemplate, ArrayLiteralNode, ArrowFunctionNode, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BinaryOpNode, BuiltInValidatorConfig, ButtonLogicContext, CallExpressionNode, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComparisonOperator, ComponentAddon, ComputedMemberAccessNode, ConditionalExpression, ConditionalNode, ContainerAllowedChildren, ContainerComponent, ContainerField, ContainerFieldTypes, ContainerLogicConfig, CrossFieldDetectionContext, CssWrapper, CustomCondition, CustomFnConfig, CustomFunction, CustomFunctionOptions, CustomFunctionScope, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DerivationLogConfig, DerivationLogLevel, DerivationLogicConfig, DerivedFromDeferredOptions, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldAddonSupport, FieldAddonSupportEntry, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTreeRecord, FieldTypeDefinition, FieldValueCondition, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, FunctionHttpValidatorConfig, GroupAllowedChildren, GroupComponent, GroupContext, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, IdentifierNode, InferFormModel, InferFormValue, InitialPageConfig, InitializationTrackingOptions, JavascriptCondition, LazyComponentLoader, LeafFieldTypes, LiteralNode, Logger, LogicConfig, LogicTrigger, MapperFn, MemberAccessNode, MemoizeOptions, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, ObjectLiteralNode, OrCondition, OrphanAddonActionContext, PageAllowedChildren, PageField, PresetCollaborators, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, RegisteredWrapperTypes, RenderReadyInput, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowComponent, RowField, RowWrapper, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, StateLogicType, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, Token, TokenContext, UnaryOpNode, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WarningTracker, WithInputSignals, WrapperAutoAssociations, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition };
+/**
+ * Plumbing shared by every `field-errors` wrapper: the slot, the inputs, the resolved
+ * error surface, and the key this wrapper claims. Subclasses supply only a template —
+ * which is the only thing that actually differs between the core default and each
+ * adapter's native markup.
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'df-mat-field-errors',
+ *   imports: [MatError],
+ *   template: `
+ *     <ng-container #fieldComponent></ng-container>
+ *     @if (ngf.errorsToDisplay()[0]; as error) {
+ *       <mat-error [id]="ngf.errorId()">{{ error.message }}</mat-error>
+ *     }
+ *   `,
+ *   providers: [provideFieldErrorDisplay(() => MatFieldErrorsWrapperComponent)],
+ * })
+ * export default class MatFieldErrorsWrapperComponent extends FieldErrorsWrapperBase {}
+ * ```
+ */
+declare abstract class FieldErrorsWrapperBase implements FieldWrapper, FieldErrorDisplayClaim {
+    readonly fieldComponent: i0.Signal<ViewContainerRef>;
+    /** Overrides the messages in `fieldInputs`. Containers forward their own. */
+    readonly validationMessages: i0.InputSignal<ValidationMessages | undefined>;
+    readonly fieldInputs: i0.InputSignal<WrapperFieldInputs | undefined>;
+    /** The field whose errors this wrapper renders — see `FieldErrorDisplayClaim`. */
+    readonly claimedKey: i0.Signal<string | undefined>;
+    /** Resolved error surface, mirroring what `injectNgForgeField()` gives a field component. */
+    protected readonly ngf: _ng_forge_dynamic_forms_internal.FieldErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldErrorsWrapperBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FieldErrorsWrapperBase, never, never, { "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Declares that a wrapper renders the wrapped field's errors, so that field's component
+ * renders none of its own.
+ *
+ * Takes a thunk because the class is still being defined when the decorator evaluates.
+ */
+declare function provideFieldErrorDisplay(wrapper: () => Type<FieldErrorDisplayClaim>): Provider;
+
+export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, EventBus, ExpressionParser, ExpressionParserError, FIELD_ERROR_DISPLAY, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FieldErrorsWrapperBase, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAddonActionRegistry, createDebouncedLogicFunction, createDefaultDerivationLogConfig, createDynamicValueFunction, createFieldValueProxy, createFormFieldStateMap, createFormStateLogicFunction, createInitializationTracker, createLogicFunction, createResolvedErrorsSignal, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getChangedKeysWithin, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldErrors, injectFieldSignalContext, injectFieldsSupportingAddons, injectNonFieldEvaluationContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, provideFieldErrorDisplay, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowError, rowFieldMapper, runPresetAction, setupInitializationTracking, shouldLog, shouldShowErrors, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
+export type { ASTNode, AddonActionContext, AddonActionHandler, AddonActionPreset, AddonShapeValidator, AddonSlot, AddonTypeDefinition, AddonTypeRegistryRef, AddonTypeSchema, AndCondition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayComponent, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemDefinition, ArrayItemTemplate, ArrayLiteralNode, ArrowFunctionNode, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BinaryOpNode, BuiltInValidatorConfig, ButtonLogicContext, CallExpressionNode, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComparisonOperator, ComponentAddon, ComputedMemberAccessNode, ConditionalExpression, ConditionalNode, ContainerAllowedChildren, ContainerComponent, ContainerField, ContainerFieldTypes, ContainerLogicConfig, ContainerValidation, CrossFieldDetectionContext, CssWrapper, CustomCondition, CustomFnConfig, CustomFunction, CustomFunctionOptions, CustomFunctionScope, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DerivationLogConfig, DerivationLogLevel, DerivationLogicConfig, DerivedFromDeferredOptions, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldAddonSupport, FieldAddonSupportEntry, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldErrorDisplayClaim, FieldErrors, FieldErrorsOptions, FieldErrorsWrapper, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTreeRecord, FieldTypeDefinition, FieldValueCondition, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, FunctionHttpValidatorConfig, GroupAllowedChildren, GroupComponent, GroupContext, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, IdentifierNode, InferFormModel, InferFormValue, InitialPageConfig, InitializationTrackingOptions, JavascriptCondition, LazyComponentLoader, LeafFieldTypes, LiteralNode, Logger, LogicConfig, LogicTrigger, MapperFn, MemberAccessNode, MemoizeOptions, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, ObjectLiteralNode, OrCondition, OrphanAddonActionContext, PageAllowedChildren, PageField, PresetCollaborators, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, RegisteredWrapperTypes, RenderReadyInput, ResolvedError, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowComponent, RowErrorSpec, RowField, RowWrapper, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, StateLogicType, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, Token, TokenContext, UnaryOpNode, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorAttachment, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WarningTracker, WithInputSignals, WrapperAutoAssociations, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition };