@ng-forge/dynamic-forms 0.6.0 → 0.7.0

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

@@ -1,9 +1,9 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as _angular_core from '@angular/core';
-import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
+import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, EnvironmentInjector, Provider, EnvironmentProviders, Resource, PipeTransform } from '@angular/core';
 import * as _angular_forms_signals from '@angular/forms/signals';
-import { FieldTree, FieldContext, ValidationError as ValidationError$1, TreeValidationResult, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
+import { FieldTree, FieldContext, TreeValidationResult, ValidationError as ValidationError$1, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
 import * as _angular_forms from '@angular/forms';
 import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
 import { FormSchema } from '@ng-forge/dynamic-forms/schema';
@@ -379,6 +379,14 @@ type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string,
  * - 'flatten': Field's children are flattened to parent level (for container fields)
  */
 type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
+/**
+ * Semantic grouping of interchangeable field UI alternatives.
+ *
+ * Used by tooling (e.g., openapi-generator) to discover which field types
+ * can substitute for each other. A field with scope 'boolean' means it's
+ * one of several ways to render a boolean value (checkbox, toggle, etc.).
+ */
+type FieldScope = 'boolean' | 'single-select' | 'multi-select' | 'text-input' | 'numeric' | 'date';
 /**
  * Configuration interface for registering custom field types.
  *
@@ -444,6 +452,8 @@ interface FieldTypeDefinition<T extends FieldDef<any> = any> {
      * ```
      */
     propsToMeta?: string[];
+    /** Semantic scope for tooling to discover interchangeable field alternatives */
+    scope?: FieldScope | FieldScope[];
 }
 /**
  * Injection token for the global field type registry.
@@ -533,56 +543,17 @@ interface FieldValueCondition {
     value?: unknown;
 }
 /**
- * Condition that compares the entire form value against an expected value.
- *
- * @deprecated Use `FieldValueCondition` for specific field checks, or
- * `JavascriptCondition` with an expression for complex form-level comparisons.
- * Will be removed in a future minor version.
- *
- * @public
- */
-interface FormValueCondition {
-    type: 'formValue';
-    /** Comparison operator */
-    operator: ComparisonOperator;
-    /** Value to compare against */
-    value?: unknown;
-}
-/**
- * Condition that invokes a registered custom function by name (new API).
+ * Condition that invokes a registered custom function by name.
  *
  * Register functions via `customFnConfig.customFunctions`.
  *
- * @internal
+ * @public
  */
-interface CustomConditionNew {
+interface CustomCondition {
     type: 'custom';
     /** Name of the registered custom function to invoke */
     functionName: string;
 }
-/**
- * @deprecated Use `CustomCondition` with `functionName` instead.
- * The `expression` field was misnamed — it holds a function registry key, not a JS expression.
- * Will be removed in a future minor version.
- *
- * @internal
- */
-interface CustomConditionDeprecated {
-    type: 'custom';
-    /**
-     * @deprecated Use `functionName` instead. Will be removed in a future minor version.
-     */
-    expression: string;
-}
-/**
- * Condition that invokes a registered custom function by name.
- *
- * Use `functionName` (new API). The `expression` field is deprecated.
- * Register functions via `customFnConfig.customFunctions`.
- *
- * @public
- */
-type CustomCondition = CustomConditionNew | CustomConditionDeprecated;
 /**
  * Condition that evaluates a JavaScript expression using the secure AST-based parser.
  *
@@ -697,7 +668,7 @@ interface OrCondition {
  *
  * @public
  */
-type ConditionalExpression = FieldValueCondition | FormValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
+type ConditionalExpression = FieldValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
 
 /**
  * Logic configuration for container fields (page, group, row, array).
@@ -1772,161 +1743,15 @@ type DebouncedFunctionDerivationLogicConfig = FunctionDerivationBase & Debounced
  * @public
  */
 type DerivationLogicConfig = OnChangeHttpDerivationLogicConfig | DebouncedHttpDerivationLogicConfig | OnChangeAsyncFunctionDerivationLogicConfig | DebouncedAsyncFunctionDerivationLogicConfig | OnChangeExpressionDerivationLogicConfig | DebouncedExpressionDerivationLogicConfig | OnChangeValueDerivationLogicConfig | DebouncedValueDerivationLogicConfig | OnChangeFunctionDerivationLogicConfig | DebouncedFunctionDerivationLogicConfig;
-/**
- * Base configuration for property derivation logic.
- *
- * Property derivations compute values for field properties (like `minDate`, `options`,
- * `label`, `placeholder`) based on form values and external data. Unlike value derivations
- * which set the field's value, property derivations update component input properties.
- *
- * All property derivations are self-targeting: the logic is placed on the field whose
- * property should be derived.
- *
- * @internal
- */
-interface BasePropertyDerivationLogicConfig {
-    /**
-     * Logic type identifier for property derivation.
-     */
-    type: 'propertyDerivation';
-    /**
-     * The target property to set on the field component.
-     *
-     * **Depth limit (max 2 levels):** Only simple and single-dot-nested paths are
-     * supported. Paths with 2+ dots (e.g., `'a.b.c'`) will throw a `DynamicFormError`
-     * at runtime. This is an architectural constraint of the override merging strategy.
-     *
-     * Supported formats:
-     * - Simple: `'minDate'`, `'options'`, `'label'`, `'placeholder'`
-     * - Nested (1 dot): `'props.appearance'`, `'meta.autocomplete'`
-     *
-     * **Note:** There is no compile-time validation that the property name matches
-     * an actual input on the field component. Typos will silently write to the
-     * override store with no visible effect. A dev-mode warning is emitted when
-     * the override key doesn't match any existing input property.
-     *
-     * @example
-     * ```typescript
-     * targetProperty: 'minDate'           // ✅ Simple property
-     * targetProperty: 'options'           // ✅ Simple property
-     * targetProperty: 'props.appearance'  // ✅ Single-nested property
-     * targetProperty: 'a.b.c'            // ❌ Throws DynamicFormError (too deep)
-     * ```
-     */
-    targetProperty: string;
-    /**
-     * Optional name for this derivation for debugging purposes.
-     *
-     * When provided, this name appears in property derivation debug logs.
-     */
-    debugName?: string;
-    /**
-     * Condition that determines when this property derivation applies.
-     *
-     * Defaults to `true` (always apply).
-     *
-     * Note: FormStateCondition is not supported for property derivations.
-     */
-    condition?: ConditionalExpression | boolean;
-    /**
-     * Static value to set on the target property.
-     *
-     * Mutually exclusive with `expression` and `functionName`.
-     */
-    value?: unknown;
-    /**
-     * JavaScript expression to evaluate for the derived property value.
-     *
-     * Has access to `formValue` object containing all form values.
-     * For array fields, `formValue` is scoped to the current array item.
-     *
-     * Mutually exclusive with `value` and `functionName`.
-     *
-     * @example
-     * ```typescript
-     * expression: 'formValue.startDate'
-     * expression: 'formValue.quantity > 10 ? "bulk" : "standard"'
-     * ```
-     */
-    expression?: string;
-    /**
-     * Name of a registered custom property derivation function.
-     *
-     * Register functions in `customFnConfig.propertyDerivations`.
-     * Mutually exclusive with `value` and `expression`.
-     */
-    functionName?: string;
-    /**
-     * Explicit field dependencies for property derivations.
-     *
-     * When using `functionName`, you can optionally specify which fields
-     * the function depends on. If not provided with `functionName`, defaults
-     * to all fields ('*').
-     * For `expression`, dependencies are automatically extracted.
-     * For `value`, no dependencies are needed (static value).
-     */
-    dependsOn?: string[];
-}
-/**
- * Property derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-interface OnChangePropertyDerivationLogicConfig extends BasePropertyDerivationLogicConfig {
-    /**
-     * Trigger for immediate evaluation.
-     * @default 'onChange'
-     */
-    trigger?: 'onChange';
-    /** Not allowed for onChange trigger */
-    debounceMs?: never;
-}
-/**
- * Property derivation that evaluates after a debounce period.
- *
- * @internal
- */
-interface DebouncedPropertyDerivationLogicConfig extends BasePropertyDerivationLogicConfig {
-    /**
-     * Trigger for debounced evaluation.
-     */
-    trigger: 'debounced';
-    /**
-     * Debounce duration in milliseconds.
-     * @default 500
-     */
-    debounceMs?: number;
-}
-/**
- * Configuration for property derivation logic.
- *
- * @deprecated Use `DerivationLogicConfig` with `targetProperty` instead.
- * The unified `type: 'derivation'` with `targetProperty` provides the same
- * functionality with a simpler API surface.
- *
- * ```typescript
- * // Before (deprecated)
- * { type: 'propertyDerivation', targetProperty: 'minDate', expression: '...' }
- *
- * // After (preferred)
- * { type: 'derivation', targetProperty: 'minDate', expression: '...' }
- * ```
- *
- * Will be removed in a future minor version.
- *
- * @public
- */
-type PropertyDerivationLogicConfig = OnChangePropertyDerivationLogicConfig | DebouncedPropertyDerivationLogicConfig;
 /**
  * Union type for all logic configurations.
  *
  * - `StateLogicConfig`: For field state changes (hidden, readonly, disabled, required)
- * - `DerivationLogicConfig`: For value derivation
- * - `PropertyDerivationLogicConfig`: For property derivation
+ * - `DerivationLogicConfig`: For value derivation (including property derivation via `targetProperty`)
  *
  * @public
  */
-type LogicConfig = StateLogicConfig | DerivationLogicConfig | PropertyDerivationLogicConfig;
+type LogicConfig = StateLogicConfig | DerivationLogicConfig;
 /**
  * Log level for derivation debug output.
  *
@@ -1946,18 +1771,6 @@ type DerivationLogLevel = 'none' | 'summary' | 'verbose';
  * @public
  */
 declare function isFormStateCondition(condition: StateLogicConfig['condition'] | DerivationLogicConfig['condition']): condition is FormStateCondition;
-/**
- * Type guard to check if a logic config is a PropertyDerivationLogicConfig.
- *
- * @deprecated Use `isDerivationLogicConfig(config) && hasTargetProperty(config)` instead.
- * Will be removed in a future minor version.
- *
- * @param config - The logic config to check
- * @returns true if the config is for property derivation
- *
- * @public
- */
-declare function isPropertyDerivationLogicConfig(config: LogicConfig): config is PropertyDerivationLogicConfig;
 
 /**
  * Interface for dynamic forms logger implementations.
@@ -2362,19 +2175,36 @@ type MaybeOptional<T, V> = T extends {
 } ? V : T extends {
     required: true;
 } ? V : V | undefined;
+/**
+ * Infers the value type from a single template field (for primitive arrays).
+ * Mirrors InferValueType logic: slider → number, input[number] → number, else string.
+ */
+type InferSingleTemplateValue<T, D extends number> = T extends {
+    type: 'slider';
+} ? number : T extends {
+    type: 'input';
+    props: {
+        type: 'number';
+    };
+} ? number : T extends {
+    type: 'checkbox' | 'toggle';
+} ? boolean : T extends {
+    value: infer V;
+} ? Widen<V, Depth[D]> : string;
 /**
  * Infers the value type for an array field.
- * Handles three cases:
+ * Handles four cases:
  * 1. Simplified array with template + value → infer item type from value
- * 2. Simplified array with template only → unknown[]
- * 3. Full-API array with fields → infer from children
+ * 2. Simplified array with array template (no value) → infer object type from template fields
+ * 3. Simplified array with single-field template (no value) → infer primitive type from template field
+ * 4. Full-API array with fields → infer from children
  */
 type InferArrayValue<T, D extends number> = T extends {
     template: unknown;
     value: readonly (infer Item)[];
 } ? Widen<Item>[] : T extends {
-    template: unknown;
-} ? unknown[] : T extends {
+    template: infer TArr;
+} ? TArr extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<[...TArr], Depth[D]>[] : InferSingleTemplateValue<TArr, D>[] : T extends {
     fields: infer F;
 } ? F extends RegisteredFieldTypes[] ? InferFormValueWithDepth<F, Depth[D]>[] : unknown[] : unknown[];
 /**
@@ -2457,11 +2287,11 @@ type InferFormValue$1<T> = ExtractFields<T> extends readonly RegisteredFieldType
  */
 interface HttpValidationResponseMapping {
     /**
-     * Expression evaluated with scope `{ response }`. Truthy = valid (no error).
+     * Expression evaluated with scope `{ response }`. Must evaluate to `true` (strict boolean) to be valid.
      *
      * NOTE: This is the OPPOSITE of the function-based HttpCustomValidator.onSuccess
      * convention, which maps successful HTTP responses to validation errors.
-     * Here, truthy means "validation passed".
+     * Here, `=== true` means "validation passed". Non-boolean results are treated as invalid and trigger a warning.
      */
     validWhen: string;
     /** Error kind returned when validation fails — maps to field-level `validationMessages` */
@@ -2527,16 +2357,10 @@ interface CustomValidatorConfig extends BaseValidatorConfig {
  * Async custom validator configuration using Angular's validateAsync API.
  * Returns Observable<ValidationError | ValidationError[] | null>.
  *
- * Accepts both `'async'` (preferred) and `'customAsync'` (deprecated) type literals.
  */
 interface AsyncValidatorConfig extends BaseValidatorConfig {
-    /**
-     * Validator type identifier.
-     *
-     * Use `'async'` for new code. `'customAsync'` is accepted for backward compatibility
-     * but emits a deprecation warning in dev mode.
-     */
-    type: 'async' | 'customAsync';
+    /** Validator type identifier. */
+    type: 'async';
     /** Name of registered async validator function */
     functionName: string;
     /** Optional parameters to pass to validator function */
@@ -2550,28 +2374,15 @@ interface AsyncValidatorConfig extends BaseValidatorConfig {
  *
  * Discriminated from `DeclarativeHttpValidatorConfig` by the presence of `functionName`.
  *
- * Accepts both `'http'` (preferred) and `'customHttp'` (deprecated) type literals.
- *
- * @deprecated Prefer `DeclarativeHttpValidatorConfig` (`type: 'http'` with `http` + `responseMapping`)
- * for fully JSON-serializable validation. Use this form only when function registration is required.
  */
 interface FunctionHttpValidatorConfig extends BaseValidatorConfig {
-    /**
-     * Validator type identifier.
-     *
-     * Use `'http'` for new code. `'customHttp'` is accepted for backward compatibility
-     * but emits a deprecation warning in dev mode.
-     */
-    type: 'http' | 'customHttp';
+    /** Validator type identifier. */
+    type: 'http';
     /** Name of registered HTTP validator configuration */
     functionName: string;
     /** Optional parameters to pass to HTTP validator */
     params?: Record<string, unknown>;
 }
-/**
- * @deprecated Use `FunctionHttpValidatorConfig` instead. Will be removed in a future minor version.
- */
-type HttpValidatorConfig = FunctionHttpValidatorConfig;
 /**
  * Declarative HTTP validator configuration — fully JSON-serializable, no function registration required.
  *
@@ -2963,7 +2774,7 @@ type FormFieldStateMap = Record<string, FieldStateInfo | undefined>;
  */
 type FieldStateContext = FieldStateInfo;
 
-interface EvaluationContext<TValue = unknown> {
+interface EvaluationContext<TValue = unknown, TFormValue extends Record<string, unknown> = any> {
     /** Current field value */
     fieldValue: TValue;
     /**
@@ -2973,7 +2784,7 @@ interface EvaluationContext<TValue = unknown> {
      * For array item derivations, this is scoped to the current array item.
      * Use `rootFormValue` to access the complete form when inside an array context.
      */
-    formValue: Record<string, unknown>;
+    formValue: TFormValue;
     /** Field path for relative references */
     fieldPath: string;
     /** Custom evaluation functions */
@@ -3114,7 +2925,7 @@ interface EvaluationContext<TValue = unknown> {
  * };
  * ```
  */
-type CustomFunction = (context: EvaluationContext) => unknown;
+type CustomFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => unknown;
 
 /**
  * Async function for derivations — returns any value.
@@ -3133,7 +2944,7 @@ type CustomFunction = (context: EvaluationContext) => unknown;
  *
  * @public
  */
-type AsyncDerivationFunction = (context: EvaluationContext) => Promise<unknown> | Observable<unknown>;
+type AsyncDerivationFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<unknown> | Observable<unknown>;
 /**
  * Async function for conditions — returns boolean.
  *
@@ -3151,7 +2962,7 @@ type AsyncDerivationFunction = (context: EvaluationContext) => Promise<unknown>
  *
  * @public
  */
-type AsyncConditionFunction = (context: EvaluationContext) => Promise<boolean> | Observable<boolean>;
+type AsyncConditionFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<boolean> | Observable<boolean>;
 
 /**
  * Re-export Angular's ValidationError for consistency
@@ -3416,7 +3227,7 @@ interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = Reg
     /**
      * Signal forms adapter configuration.
      */
-    customFnConfig?: CustomFnConfig;
+    customFnConfig?: CustomFnConfig<TValue extends Record<string, unknown> ? TValue : Record<string, unknown>>;
     /**
      * Form submission configuration.
      *
@@ -3571,7 +3382,7 @@ interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = Reg
  *
  * @public
  */
-interface CustomFnConfig {
+interface CustomFnConfig<TFormValue extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Custom evaluation functions for conditional expressions.
      *
@@ -3589,7 +3400,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    customFunctions?: Record<string, CustomFunction>;
+    customFunctions?: Record<string, CustomFunction<TFormValue>>;
     /**
      * Custom derivation functions for value derivation logic.
      *
@@ -3657,50 +3468,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    derivations?: Record<string, CustomFunction>;
-    /**
-     * @deprecated Register functions under `derivations` instead. Use `type: 'derivation'`
-     * with `targetProperty` in field logic configs. Will be removed in a future minor version.
-     *
-     * Custom property derivation functions for reactive property updates.
-     *
-     * These functions compute derived values for field properties (like `minDate`,
-     * `options`, `label`, `placeholder`) and are called when a
-     * `PropertyDerivationLogicConfig` references them by `functionName`.
-     *
-     * Property derivation functions:
-     * - Receive an `EvaluationContext` with access to `formValue`
-     * - Return the value to set on the target property
-     * - Are called reactively when dependencies change
-     *
-     * @example
-     * ```typescript
-     * propertyDerivations: {
-     *   getCitiesForCountry: (context) => {
-     *     const countryCities: Record<string, Array<{ label: string; value: string }>> = {
-     *       'USA': [{ label: 'New York', value: 'ny' }, { label: 'LA', value: 'la' }],
-     *       'Germany': [{ label: 'Berlin', value: 'berlin' }, { label: 'Munich', value: 'munich' }],
-     *     };
-     *     return countryCities[context.formValue.country as string] ?? [];
-     *   },
-     * }
-     * ```
-     *
-     * Field configuration using a property derivation function:
-     * ```typescript
-     * {
-     *   key: 'city',
-     *   type: 'select',
-     *   logic: [{
-     *     type: 'propertyDerivation',
-     *     targetProperty: 'options',
-     *     functionName: 'getCitiesForCountry',
-     *     dependsOn: ['country']
-     *   }]
-     * }
-     * ```
-     */
-    propertyDerivations?: Record<string, CustomFunction>;
+    derivations?: Record<string, CustomFunction<TFormValue>>;
     /**
      * Async derivation functions for asynchronous value derivation logic.
      *
@@ -3730,7 +3498,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    asyncDerivations?: Record<string, AsyncDerivationFunction>;
+    asyncDerivations?: Record<string, AsyncDerivationFunction<TFormValue>>;
     /**
      * Async condition functions for asynchronous field state logic.
      *
@@ -3754,7 +3522,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    asyncConditions?: Record<string, AsyncConditionFunction>;
+    asyncConditions?: Record<string, AsyncConditionFunction<TFormValue>>;
     /**
      * Custom validators using Angular's public FieldContext API
      *
@@ -3872,72 +3640,18 @@ interface CustomFnConfig {
      */
     asyncValidators?: Record<string, AsyncCustomValidator>;
     /**
-     * @deprecated Prefer declarative HTTP validators using `type: 'http'` with `http` + `responseMapping`
-     * in the validators array. Function-based HTTP validators now also use `type: 'http'` with `functionName`.
-     * Will be removed in a future minor version.
-     *
-     * HTTP validators using Angular's validateHttp() API
-     *
-     * Angular's validateHttp provides HTTP validation with automatic request
-     * cancellation and integration with the resource API.
-     *
-     * **Structure:**
-     * - `request`: Function that returns URL string or HttpResourceRequest
-     * - `onSuccess`: REQUIRED - Maps HTTP response to validation errors (inverted logic!)
-     * - `onError`: Optional handler for HTTP errors
-     *
-     * **Benefits:**
-     * - Automatic request cancellation when field value changes
-     * - Built-in integration with Angular's resource management
-     * - Simpler than asyncValidators for HTTP use cases
+     * HTTP validators using Angular's validateHttp() API.
      *
-     * **Important:** `onSuccess` uses inverted logic - it maps SUCCESSFUL HTTP responses
-     * to validation errors. For example, if the API returns `{ available: false }`,
-     * your `onSuccess` should return `{ kind: 'usernameTaken' }`.
+     * For function-based HTTP validation with automatic request cancellation.
+     * Prefer declarative HTTP validators (`type: 'http'` with `http` + `responseMapping`)
+     * for fully JSON-serializable validation when possible.
      *
-     * @example Username Availability Check (GET)
+     * @example
      * ```typescript
      * httpValidators: {
      *   checkUsername: {
-     *     request: (ctx) => {
-     *       const username = ctx.value();
-     *       if (!username) return undefined; // Skip validation if empty
-     *       return `/api/users/check-username?username=${encodeURIComponent(username)}`;
-     *     },
-     *     onSuccess: (response, ctx) => {
-     *       // Inverted logic: successful response may indicate validation failure
-     *       return response.available ? null : { kind: 'usernameTaken' };
-     *     },
-     *     onError: (error, ctx) => {
-     *       console.error('Availability check failed:', error);
-     *       return null; // Don't block form on network errors
-     *     }
-     *   }
-     * }
-     * ```
-     *
-     * @example Address Validation (POST with Body)
-     * ```typescript
-     * httpValidators: {
-     *   validateAddress: {
-     *     request: (ctx) => {
-     *       const zipCode = ctx.value();
-     *       if (!zipCode) return undefined;
-     *
-     *       return {
-     *         url: '/api/validate-address',
-     *         method: 'POST',
-     *         body: {
-     *           street: ctx.valueOf('street' as any),
-     *           city: ctx.valueOf('city' as any),
-     *           zipCode: zipCode
-     *         },
-     *         headers: { 'Content-Type': 'application/json' }
-     *       };
-     *     },
-     *     onSuccess: (response) => {
-     *       return response.valid ? null : { kind: 'invalidAddress' };
-     *     }
+     *     request: (ctx) => `/api/users/check?username=${encodeURIComponent(ctx.value())}`,
+     *     onSuccess: (response) => response.available ? null : { kind: 'usernameTaken' },
      *   }
      * }
      * ```
@@ -4322,17 +4036,13 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     value: _angular_core.ModelSignal<Partial<TModel> | undefined>;
     private destroyRef;
     private injector;
+    protected environmentInjector: EnvironmentInjector;
     private eventBus;
     private logger;
-    /**
-     * Connect input signals to the shared deps holder BEFORE injecting FormStateManager.
-     * Field initializers run in declaration order, so this runs after inputs are created
-     * but before stateManager is injected. FormStateManager reads from these signals
-     * in computeds/effects, which are all lazy and evaluated after construction.
-     */
-    private readonly _connectStateDeps;
-    /** State manager that owns all form state. */
-    private stateManager;
+    private dispatcher;
+    /** State manager that owns all form state. Initialized via connectDeps() to guarantee
+     * FORM_STATE_DEPS is populated before FormStateManager is injected. */
+    private readonly stateManager;
     private componentId;
     /** The currently active config used for form rendering */
     activeConfig: Signal<FormConfig<TFields, InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, Record<string, unknown>, unknown> | undefined>;
@@ -4370,7 +4080,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Whether any form field has been touched (blurred) */
     touched: Signal<boolean>;
     /** Current validation errors from all fields */
-    errors: Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    errors: Signal<_angular_forms_signals.ValidationError.WithFieldTree[]>;
     /** Whether the form is disabled (from options or form state) */
     disabled: Signal<boolean>;
     /** Whether the form is currently submitting */
@@ -4381,6 +4091,13 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     shouldRender: Signal<boolean>;
     /** Resolved fields ready for rendering */
     protected resolvedFields: Signal<ResolvedField[]>;
+    /**
+     * Recursively counts container components that will emit ComponentInitializedEvent.
+     * Includes the dynamic-form component itself (+1).
+     *
+     * Recurses into all container children, including those nested inside array
+     * item templates, to avoid a premature (initialized) emission.
+     */
     private totalComponentsCount;
     initialized$: rxjs.Observable<boolean>;
     /** Emits when form validity changes. */
@@ -4426,11 +4143,176 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
      */
     protected onNativeSubmit(event: Event): void;
     private setupEffects;
+    /**
+     * Populates FORM_STATE_DEPS with this component's input signals, then injects
+     * FormStateManager. Must be called as a field initializer (after the input signals
+     * are declared) so that FormStateManager reads populated deps when it is constructed.
+     * inject() is valid here because field initializers run inside the injection context.
+     */
+    private connectDeps;
     private setupEventHandlers;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicForm<any, any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicForm<any, any>, "form[dynamic-form]", never, { "config": { "alias": "dynamic-form"; "required": true; "isSignal": true; }; "formOptions": { "alias": "formOptions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; "reset": "reset"; "cleared": "cleared"; "events": "events"; "initialized": "initialized"; "onPageChange": "onPageChange"; "onPageNavigationStateChange": "onPageNavigationStateChange"; }, never, never, true, never>;
 }
 
+declare class EventBus {
+    private readonly pipeline$;
+    private readonly globalEmitFormValue;
+    private readonly rootFormRegistry;
+    private readonly formOptions;
+    private readonly logger;
+    events$: Observable<FormEvent>;
+    /**
+     * Dispatches a pre-created event instance directly.
+     *
+     * Use this overload with the `arrayEvent()` factory or any other code that
+     * produces a `FormEvent` instance rather than a constructor:
+     *
+     * ```typescript
+     * eventBus.dispatch(arrayEvent('contacts').append(template));
+     * eventBus.dispatch(arrayEvent('contacts').pop());
+     * ```
+     *
+     * @param event - A FormEvent instance to dispatch
+     */
+    dispatch(event: FormEvent): void;
+    /**
+     * Dispatches an event to all subscribers by instantiating the provided constructor.
+     *
+     * Creates an instance of the provided event constructor and broadcasts it
+     * through the event pipeline to all active subscribers.
+     *
+     * If `withEventFormValue()` is enabled globally or `options.emitFormValueOnEvents`
+     * is set to `true` in the form config, the current form value will be attached
+     * to the event's `formValue` property.
+     *
+     * @param eventConstructor - Constructor function for the event to dispatch
+     * @param args - Arguments to pass to the event constructor
+     *
+     * @example
+     * ```typescript
+     * // Dispatch a submit event
+     * eventBus.dispatch(SubmitEvent);
+     *
+     * // Dispatch a custom event with args
+     * eventBus.dispatch(CustomFormEvent, 'arg1', 42);
+     * ```
+     */
+    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
+    /**
+     * Dispatches a pre-created event instance directly.
+     * Used internally by EventDispatcher to forward events into the bus.
+     * @internal
+     */
+    emitInstance(event: FormEvent): void;
+    /**
+     * Shared emit path for both dispatch() and emitInstance().
+     * Attaches form value if configured, then pushes to the pipeline.
+     */
+    private emit;
+    /**
+     * Emits an event through the pipeline. Catches any synchronous exception that escapes
+     * RxJS's own error handling so dispatch() callers are never disrupted by a failing subscriber.
+     */
+    private safeEmit;
+    /**
+     * Determines whether form value should be attached to events.
+     *
+     * Precedence rules:
+     * 1. Per-form setting (if defined) takes precedence
+     * 2. Falls back to global setting
+     */
+    private shouldEmitFormValue;
+    /**
+     * Subscribes to events of a specific type.
+     *
+     * @param eventType - The type of event to subscribe to
+     * @returns Observable that emits events of the specified type
+     */
+    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
+    /**
+     * Subscribes to events of multiple types.
+     *
+     * @param eventType - Array of event types to subscribe to
+     * @returns Observable that emits events matching any of the specified types
+     */
+    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventBus, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventBus>;
+}
+
+/**
+ * Injectable service for dispatching events into a DynamicForm from outside the form.
+ *
+ * ## When to use
+ *
+ * Use `EventDispatcher` when you need to drive form behaviour **from the host component** —
+ * for example, appending array items in response to a field value change, triggering a form
+ * reset from a toolbar button, or reacting to external application state.
+ *
+ * This is the recommended alternative to accessing the form's internals via `viewChild`.
+ *
+ * ## Setup
+ *
+ * Provide `EventDispatcher` at the **host component** level (not root). DynamicForm
+ * automatically detects it and connects its internal event bus to the dispatcher.
+ *
+ * ```typescript
+ * @Component({
+ *   providers: [EventDispatcher],
+ *   template: `<form [dynamic-form]="config" [(value)]="formValue"></form>`
+ * })
+ * export class MyComponent {
+ *   readonly dispatcher = inject(EventDispatcher);
+ *   readonly formValue = signal<Record<string, unknown>>({});
+ *
+ *   constructor() {
+ *     effect(() => {
+ *       const category = this.formValue()?.['category'] as string | undefined;
+ *       if (category) {
+ *         this.dispatcher.dispatch(
+ *           arrayEvent('tasks').append([{ key: 'name', type: 'input', label: 'Task', value: category }])
+ *         );
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * ## Multi-form note
+ *
+ * If multiple `DynamicForm` instances exist under the same provider scope, **all forms**
+ * will receive dispatched events. To target a specific form, scope the provider to a
+ * wrapper component that contains only that form.
+ *
+ * ## What events can be dispatched
+ *
+ * Any `FormEvent` instance is accepted — array events, reset/clear events, custom events, etc.
+ * The `arrayEvent()` builder is the recommended way to construct array manipulation events:
+ *
+ * ```typescript
+ * dispatcher.dispatch(arrayEvent('tasks').append(template));
+ * dispatcher.dispatch(arrayEvent('tasks').removeAt(0));
+ * dispatcher.dispatch(new FormResetEvent());
+ * ```
+ */
+declare class EventDispatcher {
+    private bus;
+    /**
+     * Dispatches a form event into the connected DynamicForm's event bus.
+     * No-op if no form is currently connected.
+     *
+     * @param event - A FormEvent instance. Use the `arrayEvent()` builder for array operations.
+     */
+    dispatch(event: FormEvent): void;
+    /** @internal - Called by DynamicForm on init */
+    connect(bus: EventBus): void;
+    /** @internal - Called by DynamicForm on destroy */
+    disconnect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventDispatcher, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventDispatcher>;
+}
+
 /**
  * Base interface for dynamic form features.
  * Features are configuration options that can be passed to provideDynamicForm
@@ -5444,92 +5326,6 @@ declare function arrayEvent(arrayKey: string): {
     removeAt: (index: number) => RemoveAtIndexEvent;
 };
 
-/**
- * Event bus service for form-wide event communication.
- *
- * Provides type-safe event dispatching and subscription for form components
- * to communicate without direct coupling. Uses RxJS observables for reactive
- * event handling and supports both single event type and multiple event type subscriptions.
- *
- * @example
- * ```typescript
- * @Component({
- *   providers: [EventBus]
- * })
- * export class MyFormComponent {
- *   constructor(private eventBus: EventBus) {
- *     // Subscribe to form submission events
- *     this.eventBus.on<SubmitEvent>('submit').subscribe(() => {
- *       console.log('Form was submitted');
- *     });
- *
- *     // Subscribe to multiple event types
- *     this.eventBus.on<SubmitEvent | FormResetEvent>(['submit', 'form-reset']).subscribe(event => {
- *       console.log('Form event:', event.type);
- *     });
- *   }
- *
- *   onSubmit() {
- *     // Dispatch a submit event
- *     this.eventBus.dispatch(SubmitEvent);
- *   }
- * }
- * ```
- */
-declare class EventBus {
-    private readonly pipeline$;
-    private readonly globalEmitFormValue;
-    private readonly rootFormRegistry;
-    private readonly formOptions;
-    events$: Observable<FormEvent>;
-    /**
-     * Dispatches an event to all subscribers.
-     *
-     * Creates an instance of the provided event constructor and broadcasts it
-     * through the event pipeline to all active subscribers.
-     *
-     * If `withEventFormValue()` is enabled globally or `options.emitFormValueOnEvents`
-     * is set to `true` in the form config, the current form value will be attached
-     * to the event's `formValue` property.
-     *
-     * @param eventConstructor - Constructor function for the event to dispatch
-     *
-     * @example
-     * ```typescript
-     * // Dispatch a submit event
-     * eventBus.dispatch(SubmitEvent);
-     *
-     * // Dispatch a custom event
-     * eventBus.dispatch(CustomFormEvent);
-     * ```
-     */
-    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
-    /**
-     * Determines whether form value should be attached to events.
-     *
-     * Precedence rules:
-     * 1. Per-form setting (if defined) takes precedence
-     * 2. Falls back to global setting
-     */
-    private shouldEmitFormValue;
-    /**
-     * Subscribes to events of a specific type.
-     *
-     * @param eventType - The type of event to subscribe to
-     * @returns Observable that emits events of the specified type
-     */
-    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
-    /**
-     * Subscribes to events of multiple types.
-     *
-     * @param eventType - Array of event types to subscribe to
-     * @returns Observable that emits events matching any of the specified types
-     */
-    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventBus, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventBus>;
-}
-
 /**
  * Context for token resolution in event args
  */
@@ -5847,6 +5643,26 @@ declare function dynamicTextToObservable(value: DynamicText | undefined, injecto
  */
 declare function applyMetaToElement(element: Element, meta: FieldMeta | undefined, previouslyApplied: Set<string>): Set<string>;
 
+/**
+ * Wraps a `Resource` so that the previous resolved value is preserved while the resource
+ * is loading or reloading. This prevents UI flicker when params change and a new request
+ * is in-flight — the consumer sees the stale value with a `loading`/`reloading` status
+ * instead of `undefined`.
+ *
+ * Uses Angular's `resource.snapshot` + `resourceFromSnapshots` composition pattern.
+ *
+ * @example
+ * ```typescript
+ * const user = withPreviousValue(
+ *   resource({ params: () => userId(), loader: ({ params }) => fetchUser(params) })
+ * );
+ * // user.value() keeps the old user data during loading transitions
+ * ```
+ *
+ * @experimental Uses Angular's experimental resource composition APIs.
+ */
+declare function withPreviousValue<T>(input: Resource<T>): Resource<T>;
+
 /**
  * Pipe that handles dynamic text resolution with support for static strings,
  * Observables, and Signals.
@@ -5894,6 +5710,7 @@ declare class RowFieldComponent {
     private readonly destroyRef;
     private readonly fieldRegistry;
     private readonly injector;
+    protected readonly environmentInjector: EnvironmentInjector;
     private readonly eventBus;
     private readonly logger;
     field: _angular_core.InputSignal<RowField<readonly _ng_forge_dynamic_forms.RowAllowedChildren[]>>;
@@ -5923,6 +5740,7 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly fieldRegistry;
     private readonly parentFieldSignalContext;
     private readonly injector;
+    protected readonly environmentInjector: EnvironmentInjector;
     private readonly eventBus;
     private readonly logger;
     private readonly fieldProcessors;
@@ -5946,7 +5764,7 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     readonly invalid: _angular_core.Signal<boolean>;
     readonly dirty: _angular_core.Signal<boolean>;
     readonly touched: _angular_core.Signal<boolean>;
-    readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithFieldTree[]>;
     readonly disabled: _angular_core.Signal<boolean>;
     private readonly nestedFieldTree;
     private readonly groupFieldSignalContext;
@@ -5999,6 +5817,7 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly fieldRegistry;
     private readonly parentFieldSignalContext;
     private readonly parentInjector;
+    protected readonly environmentInjector: EnvironmentInjector;
     private readonly eventBus;
     private readonly logger;
     private readonly templateRegistry;
@@ -6007,7 +5826,7 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     key: _angular_core.InputSignal<string>;
     className: _angular_core.InputSignal<string | undefined>;
     hidden: _angular_core.InputSignal<boolean>;
-    readonly hostClasses: _angular_core.Signal<string>;
+    readonly hostClasses: Signal<string>;
     private readonly rawFieldRegistry;
     /**
      * Gets the auto-remove button FieldDef from normalization metadata.
@@ -6052,7 +5871,12 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
      */
     private readonly itemPositionMap;
     /** Read-only view of resolved items for template consumption. */
-    readonly resolvedItems: _angular_core.Signal<ResolvedArrayItem[]>;
+    readonly resolvedItems: Signal<ResolvedArrayItem[]>;
+    /**
+     * Whether the array has reached its configured maxLength.
+     * Exposed as a public signal so add-button components can bind [disabled]="atMaxLength()".
+     */
+    readonly atMaxLength: Signal<boolean>;
     /**
      * Caches the result of appending the auto-remove button to template arrays.
      * Keyed by template array reference — cache hits occur during recreate/resolution
@@ -6191,5 +6015,12 @@ declare class RootFormRegistryService {
     constructor(formValue: Signal<Record<string, unknown>>, rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>);
 }
 
-export { ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, InsertArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, RootFormRegistryService, RowFieldComponent, ShiftArrayItemEvent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayEvent, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, evaluateNonFieldDisabled, evaluateNonFieldHidden, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isPropertyDerivationLogicConfig, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig, withValueExclusionDefaults };
-export type { ArrayAllowedChildren, ArrayButtonConfig, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, ArrayItemDefinitionTemplate, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, PageAllowedChildren, PageField, Prettify, PropertyDerivationLogicConfig, RegisteredFieldTypes, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };
+/**
+ * Injection token for configuring the initialization timeout in milliseconds.
+ * Defaults to 10 seconds. When the timeout is reached, a warning is logged
+ * and (initialized) emits true as a best-effort fallback.
+ */
+declare const INITIALIZATION_TIMEOUT_MS: InjectionToken<number>;
+
+export { ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, EventDispatcher, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, INITIALIZATION_TIMEOUT_MS, InsertArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, RootFormRegistryService, RowFieldComponent, ShiftArrayItemEvent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayEvent, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, evaluateNonFieldDisabled, evaluateNonFieldHidden, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig, withPreviousValue, withValueExclusionDefaults };
+export type { ArrayAllowedChildren, ArrayButtonConfig, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, ArrayItemDefinitionTemplate, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };