@ng-forge/dynamic-forms 1.3.0-next.2 → 1.3.0-next.3

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

@@ -1,13 +1,15 @@
-import * as rxjs from 'rxjs';
-import * as _angular_forms_signals from '@angular/forms/signals';
-import { FieldTree } from '@angular/forms/signals';
-import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
-import { FormEvent, FieldDef, RegisteredFieldTypes, InferFormModel, FormConfig, FormOptions, EventBus, LazyComponentLoader, WrapperTypeDefinition, FieldTypeDefinition, InferFormValue as InferFormValue$1, DerivationLogLevel, Logger, ValueExclusionConfig, ValidationExecutionConfig, TextAddon, WrapperFieldInputs, TemplateAddon, ComponentAddon, BaseAddon, AddonTypeDefinition, AddonActionHandler, ArrayItemDefinition } from '@ng-forge/dynamic-forms/internal';
-export { AddonActionContext, AddonActionPreset, AddonSlot, AddonTypeDefinition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormValue, InitialPageConfig, LeafFieldTypes, Logger, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowErrorSpec, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueType, WebMcpToolOptions, WithInputSignals, WrapperConfig, WrapperTypeDefinition, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue, rowError } from '@ng-forge/dynamic-forms/internal';
-import * as _angular_core from '@angular/core';
-import { Type, Injector, Signal, EnvironmentInjector, WritableSignal, Provider, EnvironmentProviders, TemplateRef } from '@angular/core';
-import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
-
+import { AddonActionContext, AddonActionHandler, AddonActionPreset, AddonSlot, AddonTypeDefinition, AddonTypeDefinition as AddonTypeDefinition$1, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemDefinition, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseAddon as BaseAddon$1, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ComponentAddon as ComponentAddon$1, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DerivationLogLevel, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, EventBus, ExtractField, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldDef as FieldDef$1, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldTypeDefinition, FieldWithValidation, FieldWrapper, FormConfig, FormConfig as FormConfig$1, FormEvent, FormEvent as FormEvent$1, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormOptions as FormOptions$1, FormStateCondition, GroupAllowedChildren, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormModel, InferFormValue, InferFormValue as InferFormValue$1, InitialPageConfig, LazyComponentLoader, LeafFieldTypes, Logger, Logger as Logger$1, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, RegisteredActionRef, RegisteredFieldTypes, RegisteredFieldTypes as RegisteredFieldTypes$1, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowErrorSpec, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TemplateAddon as TemplateAddon$1, TextAddon, TextAddon as TextAddon$1, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationExecutionConfig as ValidationExecutionConfig$1, ValidationMessage, ValidationMessageResolver, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueExclusionConfig as ValueExclusionConfig$1, ValueFieldComponent, ValueType, WebMcpToolOptions, WithInputSignals, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition, WrapperTypeDefinition as WrapperTypeDefinition$1, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue, rowError } from "@ng-forge/dynamic-forms/internal";
+import * as i0 from "@angular/core";
+import { EnvironmentInjector, EnvironmentProviders, Injector, Provider, Signal, TemplateRef, Type, WritableSignal } from "@angular/core";
+import { FieldTree } from "@angular/forms/signals";
+import "rxjs";
+import "@ng-forge/dynamic-forms/schema";
+/** Error from async field component loading. */
+interface FieldLoadingError {
+  readonly fieldType: string;
+  readonly fieldKey: string;
+  readonly error: Error;
+}
 /**
  * Global default configuration for progressive field mounting ("field
  * windowing"): fields beyond `eager` render as `@defer (on viewport)`
@@ -17,14 +19,14 @@ import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
  * @internal
  */
 interface FieldWindowingConfig {
-    /** Whether field windowing is active. */
-    readonly enabled: boolean;
-    /** Number of leading fields mounted eagerly (not windowed). */
-    readonly eager: number;
-    /** CSS `min-height` reserved for each unmounted field's placeholder. */
-    readonly placeholderHeight: string;
-    /** Parking: hold scrolled-away fields out of change detection, DOM intact. */
-    readonly park: FieldParkingConfig;
+  /** Whether field windowing is active. */
+  readonly enabled: boolean;
+  /** Number of leading fields mounted eagerly (not windowed). */
+  readonly eager: number;
+  /** CSS `min-height` reserved for each unmounted field's placeholder. */
+  readonly placeholderHeight: string;
+  /** Parking: hold scrolled-away fields out of change detection, DOM intact. */
+  readonly park: FieldParkingConfig;
 }
 /**
  * Parking config. `@defer (on viewport)` only ever mounts — it never unmounts —
@@ -43,59 +45,47 @@ interface FieldWindowingConfig {
  * @internal
  */
 interface FieldParkingConfig {
-    /** Whether scrolled-away fields are held out of change detection. */
-    readonly enabled: boolean;
-    /** `IntersectionObserver` rootMargin — how far outside the viewport stays live. */
-    readonly margin: string;
+  /** Whether scrolled-away fields are held out of change detection. */
+  readonly enabled: boolean;
+  /** `IntersectionObserver` rootMargin — how far outside the viewport stays live. */
+  readonly margin: string;
 }
-
-/** Error from async field component loading. */
-interface FieldLoadingError {
-    readonly fieldType: string;
-    readonly fieldKey: string;
-    readonly error: Error;
-}
-
 /** Event dispatched when the form should be cleared. */
-declare class FormClearEvent implements FormEvent {
-    readonly type: "form-clear";
+export declare class FormClearEvent implements FormEvent$1 {
+  readonly type: "form-clear";
 }
-
 /** Event dispatched when the form should be reset to its default values. */
-declare class FormResetEvent implements FormEvent {
-    readonly type: "form-reset";
+export declare class FormResetEvent implements FormEvent$1 {
+  readonly type: "form-reset";
 }
-
 /** Event emitted when the active page of a paged form changes. */
-declare class PageChangeEvent implements FormEvent {
-    /** The current page index (0-based) */
-    readonly currentPageIndex: number;
-    /** Total number of pages */
-    readonly totalPages: number;
-    /** Previous page index (0-based), undefined if first navigation */
-    readonly previousPageIndex?: number | undefined;
-    readonly type: "page-change";
-    constructor(
-    /** The current page index (0-based) */
-    currentPageIndex: number, 
-    /** Total number of pages */
-    totalPages: number, 
-    /** Previous page index (0-based), undefined if first navigation */
-    previousPageIndex?: number | undefined);
+export declare class PageChangeEvent implements FormEvent$1 {
+  /** The current page index (0-based) */
+  readonly currentPageIndex: number;
+  /** Total number of pages */
+  readonly totalPages: number;
+  /** Previous page index (0-based), undefined if first navigation */
+  readonly previousPageIndex?: number | undefined;
+  readonly type: "page-change";
+  constructor(
+  /** The current page index (0-based) */
+  currentPageIndex: number,
+  /** Total number of pages */
+  totalPages: number,
+  /** Previous page index (0-based), undefined if first navigation */
+  previousPageIndex?: number | undefined);
 }
-
 /** Navigation state of a paged form, as emitted by `PagerStateEvent`. */
 interface PagerState {
-    /** Current page index (0-based) */
-    currentPageIndex: number;
-    /** Total number of pages */
-    totalPages: number;
-    /** Whether the current page is the first visible page */
-    isFirstPage: boolean;
-    /** Whether the current page is the last visible page */
-    isLastPage: boolean;
+  /** Current page index (0-based) */
+  currentPageIndex: number;
+  /** Total number of pages */
+  totalPages: number;
+  /** Whether the current page is the first visible page */
+  isFirstPage: boolean;
+  /** Whether the current page is the last visible page */
+  isLastPage: boolean;
 }
-
 /**
  * Event emitted whenever the pager state of a paged form changes.
  *
@@ -104,40 +94,37 @@ interface PagerState {
  * `isLastPage` flip because a page's `hidden` logic toggled and the set of
  * visible pages shifted, with the active page never moving.
  */
-declare class PagerStateEvent implements FormEvent {
-    state: PagerState;
-    readonly type: "pager-state";
-    constructor(state: PagerState);
+export declare class PagerStateEvent implements FormEvent$1 {
+  state: PagerState;
+  readonly type: "pager-state";
+  constructor(state: PagerState);
 }
-
 /** Emitted after the active page and all of its visible fields have rendered. */
-declare class ActivePageInitializedEvent implements FormEvent {
-    readonly pageIndex: number;
-    readonly pageKey: string;
-    readonly type: "active-page-initialized";
-    constructor(pageIndex: number, pageKey: string);
+export declare class ActivePageInitializedEvent implements FormEvent$1 {
+  readonly pageIndex: number;
+  readonly pageKey: string;
+  readonly type: "active-page-initialized";
+  constructor(pageIndex: number, pageKey: string);
 }
-
 /** Resolved field ready for rendering with ngComponentOutlet / DfFieldOutlet. */
 interface ResolvedField {
-    key: string;
-    /** The original field definition (used by DfFieldOutlet to resolve wrappers). */
-    fieldDef: FieldDef<unknown>;
-    component: Type<unknown>;
-    injector: Injector;
-    inputs: Signal<Record<string, unknown>>;
-    renderReady: Signal<boolean>;
-    /**
-     * Whether the field is currently hidden. Sourced from the FieldTree's
-     * `state.hidden()` for value-bearing fields (set by Angular Signal Forms in
-     * response to `hidden(path, …)` calls), or from the mapper's explicit
-     * `hidden` input for non-value fields (button, text, container, …). Consumers
-     * must `@if (!field.hidden())` around `*dfFieldOutlet` so hidden fields are
-     * removed from the DOM — Angular Signal Forms warns (NG01916) otherwise.
-     */
-    hidden: Signal<boolean>;
+  key: string;
+  /** The original field definition (used by DfFieldOutlet to resolve wrappers). */
+  fieldDef: FieldDef$1<unknown>;
+  component: Type<unknown>;
+  injector: Injector;
+  inputs: Signal<Record<string, unknown>>;
+  renderReady: Signal<boolean>;
+  /**
+   * Whether the field is currently hidden. Sourced from the FieldTree's
+   * `state.hidden()` for value-bearing fields (set by Angular Signal Forms in
+   * response to `hidden(path, …)` calls), or from the mapper's explicit
+   * `hidden` input for non-value fields (button, text, container, …). Consumers
+   * must `@if (!field.hidden())` around `*dfFieldOutlet` so hidden fields are
+   * removed from the DOM — Angular Signal Forms warns (NG01916) otherwise.
+   */
+  hidden: Signal<boolean>;
 }
-
 /**
  * Renders a form from a {@link FormConfig}. Attribute component on a native
  * `<form>` element (selector `form[dynamic-form]`); state management is
@@ -168,188 +155,220 @@ interface ResolvedField {
  * }
  * ```
  */
-declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel extends Record<string, unknown> = InferFormModel<TFields>> {
-    /** Form configuration defining the structure, validation, and behavior. */
-    config: _angular_core.InputSignal<FormConfig<TFields, _ng_forge_dynamic_forms.InferFormValue<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, Record<string, unknown>, unknown>>;
-    /** Runtime form options that override config options when provided. */
-    formOptions: _angular_core.InputSignal<FormOptions | undefined>;
-    /** Form values for two-way data binding. */
-    value: _angular_core.ModelSignal<Partial<TModel> | undefined>;
-    /**
-     * How lenient the addon validator is on `config.fields[...].addons`.
-     * `'inline'` (default) keeps everything; `'json'` drops code-only types
-     * with a warning. Read at form init and on every config swap — change
-     * `source` AND the config to force re-validation mid-flight.
-     */
-    source: _angular_core.InputSignal<"json" | "inline">;
-    private destroyRef;
-    private injector;
-    protected environmentInjector: EnvironmentInjector;
-    private eventBus;
-    private logger;
-    private dispatcher;
-    private templateRegistry;
-    private globalFieldWindowing;
-    /** All `<ng-template dfTemplate="...">` instances projected into this form. */
-    private readonly _projectedTemplates;
-    private readonly stateManager;
-    /**
-     * Owns this form's DOM-id prefix and registers the instance with the root
-     * registry for multi-form collision detection. Injected eagerly (not lazily
-     * via first field map) so the live-form count is accurate from construction.
-     */
-    private readonly formIdPrefix;
-    /** Active DOM-id prefix — empty unless explicitly set or multiple forms are mounted. */
-    protected readonly idPrefix: Signal<string>;
-    private componentId;
-    /** The currently active config used for form rendering */
-    activeConfig: Signal<FormConfig<TFields, _ng_forge_dynamic_forms.InferFormValue<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, Record<string, unknown>, unknown> | undefined>;
-    /** Current render phase: 'render' = showing form, 'teardown' = hiding old components */
-    renderPhase: Signal<"teardown" | "render">;
-    /** Computed form mode detection with validation */
-    formModeDetection: Signal<_ng_forge_dynamic_forms.FormModeDetectionResult>;
-    /** Page field definitions for paged forms */
-    pageFieldDefinitions: Signal<_ng_forge_dynamic_forms.PageField<_ng_forge_dynamic_forms.PageAllowedChildren[]>[]>;
-    /** Effective form options (merged from config and input) */
-    effectiveFormOptions: Signal<{
-        disabled?: boolean;
-        idPrefix?: string;
-        maxDerivationIterations?: number;
-        submitButton?: _ng_forge_dynamic_forms.SubmitButtonOptions;
-        nextButton?: _ng_forge_dynamic_forms.NextButtonOptions;
-        initialPage?: number | _ng_forge_dynamic_forms.InitialPageConfig;
-        pagePreloadWindow?: number;
-        fieldWindowing?: boolean | {
-            eager?: number;
-            placeholderHeight?: string;
-            park?: boolean | {
-                margin?: string;
-            };
-        };
-        excludeValueIfHidden?: boolean;
-        excludeValueIfDisabled?: boolean;
-        excludeValueIfReadonly?: boolean;
-        validateWhenHidden?: boolean;
-        emitFormValueOnEvents?: boolean;
-        webMcp?: _ng_forge_dynamic_forms.WebMcpToolOptions;
-    }>;
-    /** Field signal context for injection into child components */
-    fieldSignalContext: Signal<_ng_forge_dynamic_forms_internal.FieldSignalContext<TModel>>;
-    /** Default values computed from field definitions */
-    defaultValues: WritableSignal<TModel>;
-    /** The Angular Signal Form instance */
-    form: Signal<FieldTree<TModel, string | number, "writable">>;
-    /** Current form values (reactive) */
-    formValue: Signal<TModel>;
-    /** Whether the form is currently valid */
-    valid: Signal<boolean>;
-    /** Whether the form is currently invalid */
-    invalid: Signal<boolean>;
-    /** Whether any form field has been modified */
-    dirty: Signal<boolean>;
-    /** Whether any form field has been touched (blurred) */
-    touched: Signal<boolean>;
-    /** Current validation errors from all fields */
-    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 */
-    submitting: Signal<boolean>;
-    /** Collects errors from async field component loading for error boundary patterns */
-    fieldLoadingErrors: WritableSignal<FieldLoadingError[]>;
-    /** Whether to render the form template */
-    private derivationReady;
-    shouldRender: Signal<boolean>;
-    /**
-     * What the experimental WebMCP layer is doing for this form.
-     *
-     * Injecting it is also what instantiates the gate (component providers are
-     * lazy), which is what keeps the registrar lazily loaded. Intentionally absent
-     * from `shouldRender`: agent visibility must never gate render.
-     *
-     * `'disabled'` unless `withExperimentalWebMcp()` is provided; `'idle'` until a
-     * config declares `options.webMcp`; `'active'` once its tools are registered.
-     * `'failed'` and `'unsupported'` are the two ways registration does not
-     * happen, and are worth surfacing rather than guessing at.
-     *
-     * @experimental
-     */
-    readonly webMcpStatus: Signal<_ng_forge_dynamic_forms.WebMcpStatus>;
-    /** Resolved fields ready for rendering */
-    protected resolvedFields: Signal<ResolvedField[]>;
-    /**
-     * Effective field-windowing config for non-paged forms. Per-form
-     * `FormOptions.fieldWindowing` wins over the global `withFieldWindowing()`
-     * default; both fall back to disabled (fully eager).
-     */
-    protected readonly fieldWindowing: Signal<FieldWindowingConfig>;
-    private readonly initializedComponents;
-    private readonly initialPageReady;
-    private readonly initializationReady;
-    /** Replayable readiness so late subscribers cannot miss hot EventBus announcements. */
-    initialized$: rxjs.Observable<boolean>;
-    /** Emits when form validity changes. */
-    validityChange: _angular_core.OutputRef<boolean>;
-    /** Emits when form dirty state changes. */
-    dirtyChange: _angular_core.OutputRef<boolean>;
-    /** Emits form values when submitted (via FormSubmitEvent) and form is valid. */
-    submitted: _angular_core.OutputRef<TModel>;
-    /** Emits when form is reset to default values. */
-    reset: _angular_core.OutputRef<FormResetEvent>;
-    /** Emits when form is cleared to empty state. */
-    cleared: _angular_core.OutputRef<FormClearEvent>;
-    /** Emits all form events for custom event handling. */
-    events: _angular_core.OutputRef<_ng_forge_dynamic_forms.FormEvent>;
-    /**
-     * Emits when a non-paged form is fully initialized, or when the initially active page of a
-     * paged form is ready for interaction. Virtualized inactive pages are not part of initial
-     * readiness because they intentionally remain unmounted.
-     */
-    initialized: _angular_core.OutputRef<boolean>;
-    /**
-     * EXPERIMENTAL. Added alongside page preloading; the emission contract may change.
-     *
-     * Emits after the currently visible page and all of its visible fields render. Announced
-     * once per visit to a page, and again when that page is returned to. Use this when work must
-     * run after every page transition; `initialized` emits only for the initial page.
-     */
-    activePageInitialized: _angular_core.OutputRef<ActivePageInitializedEvent>;
-    /** Emits when the current page changes in paged forms. */
-    onPageChange: _angular_core.OutputRef<PageChangeEvent>;
-    /** Emits when pager state changes (currentPageIndex, totalPages, isFirstPage, isLastPage). */
-    onPageNavigationStateChange: _angular_core.OutputRef<PagerStateEvent>;
-    constructor();
-    /**
-     * Handles native form submission triggered by:
-     * - Pressing Enter in an input field
-     * - Clicking a button with type="submit"
-     * - Programmatic form.submit() calls
-     *
-     * @param event - The native submit event from the form element
-     */
-    protected onNativeSubmit(event: Event): void;
-    /**
-     * Whether a field should be deferred by field windowing. Containers are never
-     * windowed: they emit `ComponentInitializedEvent`, which the form's init
-     * tracker counts, so deferring one would stall `initialized` until it scrolls
-     * into view. Leaf fields carry no such count, so they defer freely.
-     */
-    protected windowsField(field: ResolvedField, index: number): boolean;
-    /** Class string for a windowed field's placeholder — matches the real field's grid column. */
-    protected placeholderGridClass(field: ResolvedField): string;
-    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; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; "reset": "reset"; "cleared": "cleared"; "events": "events"; "initialized": "initialized"; "activePageInitialized": "activePageInitialized"; "onPageChange": "onPageChange"; "onPageNavigationStateChange": "onPageNavigationStateChange"; }, ["_projectedTemplates"], never, true, never>;
+export declare class DynamicForm<TFields extends RegisteredFieldTypes$1[] = RegisteredFieldTypes$1[], TModel extends Record<string, unknown> = InferFormModel<TFields>> {
+  /** Form configuration defining the structure, validation, and behavior. */
+  config: import("@angular/core").InputSignal<FormConfig$1<TFields, import("@ng-forge/dynamic-forms").InferFormValue<TFields extends readonly RegisteredFieldTypes$1[] ? TFields : RegisteredFieldTypes$1[]>, Record<string, unknown>, unknown>>;
+  /** Runtime form options that override config options when provided. */
+  formOptions: import("@angular/core").InputSignal<FormOptions$1 | undefined>;
+  /** Form values for two-way data binding. */
+  value: import("@angular/core").ModelSignal<Partial<TModel> | undefined>;
+  /**
+   * How lenient the addon validator is on `config.fields[...].addons`.
+   * `'inline'` (default) keeps everything; `'json'` drops code-only types
+   * with a warning. Read at form init and on every config swap — change
+   * `source` AND the config to force re-validation mid-flight.
+   */
+  source: import("@angular/core").InputSignal<"json" | "inline">;
+  private destroyRef;
+  private injector;
+  protected environmentInjector: EnvironmentInjector;
+  private eventBus;
+  private logger;
+  private dispatcher;
+  private templateRegistry;
+  private globalFieldWindowing;
+  /** All `<ng-template dfTemplate="...">` instances projected into this form. */
+  private readonly _projectedTemplates;
+  private readonly stateManager;
+  /**
+   * Owns this form's DOM-id prefix and registers the instance with the root
+   * registry for multi-form collision detection. Injected eagerly (not lazily
+   * via first field map) so the live-form count is accurate from construction.
+   */
+  private readonly formIdPrefix;
+  /** Active DOM-id prefix — empty unless explicitly set or multiple forms are mounted. */
+  protected readonly idPrefix: Signal<string>;
+  private componentId;
+  /** The currently active config used for form rendering */
+  activeConfig: Signal<FormConfig$1<TFields, import("@ng-forge/dynamic-forms").InferFormValue<TFields extends readonly RegisteredFieldTypes$1[] ? TFields : RegisteredFieldTypes$1[]>, Record<string, unknown>, unknown> | undefined>;
+  /** Current render phase: 'render' = showing form, 'teardown' = hiding old components */
+  renderPhase: Signal<"teardown" | "render">;
+  /** Computed form mode detection with validation */
+  formModeDetection: Signal<import("@ng-forge/dynamic-forms").FormModeDetectionResult>;
+  /** Page field definitions for paged forms */
+  pageFieldDefinitions: Signal<import("@ng-forge/dynamic-forms").PageField<import("@ng-forge/dynamic-forms").PageAllowedChildren[]>[]>;
+  /** Effective form options (merged from config and input) */
+  effectiveFormOptions: Signal<{
+    disabled?: boolean;
+    idPrefix?: string;
+    maxDerivationIterations?: number;
+    submitButton?: import("@ng-forge/dynamic-forms").SubmitButtonOptions;
+    nextButton?: import("@ng-forge/dynamic-forms").NextButtonOptions;
+    initialPage?: number | import("@ng-forge/dynamic-forms").InitialPageConfig;
+    pagePreloadWindow?: number;
+    fieldWindowing?: boolean | {
+      eager?: number;
+      placeholderHeight?: string;
+      park?: boolean | {
+        margin?: string;
+      };
+    };
+    excludeValueIfHidden?: boolean;
+    excludeValueIfDisabled?: boolean;
+    excludeValueIfReadonly?: boolean;
+    validateWhenHidden?: boolean;
+    emitFormValueOnEvents?: boolean;
+    webMcp?: import("@ng-forge/dynamic-forms").WebMcpToolOptions;
+  }>;
+  /** Field signal context for injection into child components */
+  fieldSignalContext: Signal<import("@ng-forge/dynamic-forms/internal").FieldSignalContext<TModel>>;
+  /** Default values computed from field definitions */
+  defaultValues: WritableSignal<TModel>;
+  /** The Angular Signal Form instance */
+  form: Signal<FieldTree<TModel, string | number, "writable">>;
+  /** Current form values (reactive) */
+  formValue: Signal<TModel>;
+  /** Whether the form is currently valid */
+  valid: Signal<boolean>;
+  /** Whether the form is currently invalid */
+  invalid: Signal<boolean>;
+  /** Whether any form field has been modified */
+  dirty: Signal<boolean>;
+  /** Whether any form field has been touched (blurred) */
+  touched: Signal<boolean>;
+  /** Current validation errors from all fields */
+  errors: Signal<import("@angular/forms/signals").ValidationError.WithFieldTree[]>;
+  /** Whether the form is disabled (from options or form state) */
+  disabled: Signal<boolean>;
+  /** Whether the form is currently submitting */
+  submitting: Signal<boolean>;
+  /** Collects errors from async field component loading for error boundary patterns */
+  fieldLoadingErrors: WritableSignal<FieldLoadingError[]>;
+  /** Whether to render the form template */
+  private derivationReady;
+  shouldRender: Signal<boolean>;
+  /**
+   * What the experimental WebMCP layer is doing for this form.
+   *
+   * Injecting it is also what instantiates the gate (component providers are
+   * lazy), which is what keeps the registrar lazily loaded. Intentionally absent
+   * from `shouldRender`: agent visibility must never gate render.
+   *
+   * `'disabled'` unless `withExperimentalWebMcp()` is provided; `'idle'` until a
+   * config declares `options.webMcp`; `'active'` once its tools are registered.
+   * `'failed'` and `'unsupported'` are the two ways registration does not
+   * happen, and are worth surfacing rather than guessing at.
+   *
+   * @experimental
+   */
+  readonly webMcpStatus: Signal<import("@ng-forge/dynamic-forms").WebMcpStatus>;
+  /** Resolved fields ready for rendering */
+  protected resolvedFields: Signal<ResolvedField[]>;
+  /**
+   * Effective field-windowing config for non-paged forms. Per-form
+   * `FormOptions.fieldWindowing` wins over the global `withFieldWindowing()`
+   * default; both fall back to disabled (fully eager).
+   */
+  protected readonly fieldWindowing: Signal<FieldWindowingConfig>;
+  private readonly initializedComponents;
+  private readonly initialPageReady;
+  private readonly initializationReady;
+  /** Replayable readiness so late subscribers cannot miss hot EventBus announcements. */
+  initialized$: import("rxjs").Observable<boolean>;
+  /** Emits when form validity changes. */
+  validityChange: import("@angular/core").OutputRef<boolean>;
+  /** Emits when form dirty state changes. */
+  dirtyChange: import("@angular/core").OutputRef<boolean>;
+  /** Emits form values when submitted (via FormSubmitEvent) and form is valid. */
+  submitted: import("@angular/core").OutputRef<TModel>;
+  /** Emits when form is reset to default values. */
+  reset: import("@angular/core").OutputRef<FormResetEvent>;
+  /** Emits when form is cleared to empty state. */
+  cleared: import("@angular/core").OutputRef<FormClearEvent>;
+  /** Emits all form events for custom event handling. */
+  events: import("@angular/core").OutputRef<import("@ng-forge/dynamic-forms").FormEvent>;
+  /**
+   * Emits when a non-paged form is fully initialized, or when the initially active page of a
+   * paged form is ready for interaction. Virtualized inactive pages are not part of initial
+   * readiness because they intentionally remain unmounted.
+   */
+  initialized: import("@angular/core").OutputRef<boolean>;
+  /**
+   * EXPERIMENTAL. Added alongside page preloading; the emission contract may change.
+   *
+   * Emits after the currently visible page and all of its visible fields render. Announced
+   * once per visit to a page, and again when that page is returned to. Use this when work must
+   * run after every page transition; `initialized` emits only for the initial page.
+   */
+  activePageInitialized: import("@angular/core").OutputRef<ActivePageInitializedEvent>;
+  /** Emits when the current page changes in paged forms. */
+  onPageChange: import("@angular/core").OutputRef<PageChangeEvent>;
+  /** Emits when pager state changes (currentPageIndex, totalPages, isFirstPage, isLastPage). */
+  onPageNavigationStateChange: import("@angular/core").OutputRef<PagerStateEvent>;
+  constructor();
+  /**
+   * Handles native form submission triggered by:
+   * - Pressing Enter in an input field
+   * - Clicking a button with type="submit"
+   * - Programmatic form.submit() calls
+   *
+   * @param event - The native submit event from the form element
+   */
+  protected onNativeSubmit(event: Event): void;
+  /**
+   * Whether a field should be deferred by field windowing. Containers are never
+   * windowed: they emit `ComponentInitializedEvent`, which the form's init
+   * tracker counts, so deferring one would stall `initialized` until it scrolls
+   * into view. Leaf fields carry no such count, so they defer freely.
+   */
+  protected windowsField(field: ResolvedField, index: number): boolean;
+  /** Class string for a windowed field's placeholder — matches the real field's grid column. */
+  protected placeholderGridClass(field: ResolvedField): string;
+  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: i0.ɵɵFactoryDeclaration<DynamicForm<any, any>, never>;
+  static ɵcmp: i0.ɵɵ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;
+    };
+    "source": {
+      "alias": "source";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "validityChange": "validityChange";
+    "dirtyChange": "dirtyChange";
+    "submitted": "submitted";
+    "reset": "reset";
+    "cleared": "cleared";
+    "events": "events";
+    "initialized": "initialized";
+    "activePageInitialized": "activePageInitialized";
+    "onPageChange": "onPageChange";
+    "onPageNavigationStateChange": "onPageNavigationStateChange";
+  }, ["_projectedTemplates"], never, true, never>;
 }
-
 /**
  * Injectable service for dispatching events into a DynamicForm from outside the form.
  *
@@ -391,88 +410,81 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
  * 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>;
+export 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$1): void;
+  /** @internal - Called by DynamicForm on init */
+  connect(bus: EventBus): void;
+  /** @internal - Called by DynamicForm on destroy */
+  disconnect(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EventDispatcher, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-
 /**
  * Base interface for dynamic form features.
  * Features are configuration options that can be passed to provideDynamicForm
  * alongside field type definitions.
  */
 interface DynamicFormFeature<TKind extends string = string> {
-    /** Internal marker to identify this as a feature, not a field type */
-    ɵkind: TKind;
-    /** Providers to register for this feature */
-    ɵproviders: Provider[];
+  /** Internal marker to identify this as a feature, not a field type */
+  ɵkind: TKind;
+  /** Providers to register for this feature */
+  ɵproviders: Provider[];
 }
-
 /** User-facing wrapper registration shape used with `createWrappers(...)`. */
 interface WrapperRegistration<TName extends string = string, TConfig = unknown> {
-    /** Unique identifier for the wrapper type */
-    readonly wrapperName: TName;
-    /** Lazy-loader for the wrapper component */
-    readonly loadComponent: LazyComponentLoader;
-    /** Field types this wrapper auto-applies to (merged lowest-priority during wrapper resolution) */
-    readonly types?: readonly string[];
-    /**
-     * Type carrier only — runtime value is always `undefined`.
-     * Use `wrapperProps<YourConfig>()` to thread the config type.
-     */
-    readonly props?: TConfig;
+  /** Unique identifier for the wrapper type */
+  readonly wrapperName: TName;
+  /** Lazy-loader for the wrapper component */
+  readonly loadComponent: LazyComponentLoader;
+  /** Field types this wrapper auto-applies to (merged lowest-priority during wrapper resolution) */
+  readonly types?: readonly string[];
+  /**
+   * Type carrier only — runtime value is always `undefined`.
+   * Use `wrapperProps<YourConfig>()` to thread the config type.
+   */
+  readonly props?: TConfig;
 }
 /** Branded bundle returned by `createWrappers(...)`. */
 interface WrappersBundle<T extends readonly WrapperRegistration[] = readonly WrapperRegistration[]> {
-    readonly ɵkind: 'wrappers';
-    readonly ɵregistrations: T;
-    readonly ɵdefinitions: readonly WrapperTypeDefinition[];
+  readonly ɵkind: 'wrappers';
+  readonly ɵregistrations: T;
+  readonly ɵdefinitions: readonly WrapperTypeDefinition$1[];
 }
 /**
  * Bundle wrapper registrations into a single object that can be passed to
  * `provideDynamicForm(...)`.
  */
-declare function createWrappers<const T extends readonly WrapperRegistration[]>(...registrations: T): WrappersBundle<T>;
+export declare function createWrappers<const T extends readonly WrapperRegistration[]>(...registrations: T): WrappersBundle<T>;
 /** Type guard for a `WrappersBundle`. */
-declare function isWrappersBundle(value: unknown): value is WrappersBundle;
+export declare function isWrappersBundle(value: unknown): value is WrappersBundle;
 /** Derive the `FieldRegistryWrappers` augmentation shape from a wrapper bundle. */
-type InferWrapperRegistry<T> = T extends WrappersBundle<infer R> ? {
-    [Reg in R[number] as Reg['wrapperName']]: Reg extends {
-        props: infer P;
-    } ? Exclude<P, undefined> : {
-        readonly type: Reg['wrapperName'];
-    };
-} : never;
-
+type InferWrapperRegistry<T> = T extends WrappersBundle<infer R> ? { [Reg in R[number] as Reg['wrapperName']]: Reg extends {
+  props: infer P;
+} ? Exclude<P, undefined> : {
+  readonly type: Reg['wrapperName'];
+}; } : never;
 /** Extract FieldDef type from FieldTypeDefinition */
 type ExtractFieldDef<T> = T extends FieldTypeDefinition<infer F> ? F : never;
 /** Union of all FieldDef types from provided field types */
 type FieldDefUnion<T extends FieldTypeDefinition[]> = ExtractFieldDef<T[number]>;
 /** Infer form value type from field definitions using the real inference type. */
-type InferFormValue<TFieldDefs extends FieldDef<unknown>[]> = InferFormValue$1<TFieldDefs>;
+type InferFormValue$2<TFieldDefs extends FieldDef$1<unknown>[]> = InferFormValue$1<TFieldDefs>;
 /** Provider result with type inference */
 type ProvideDynamicFormResult<T extends FieldTypeDefinition[]> = EnvironmentProviders & {
-    __fieldDefs?: FieldDefUnion<T>;
-    __formValue?: InferFormValue<FieldDefUnion<T>[]>;
+  __fieldDefs?: FieldDefUnion<T>;
+  __formValue?: InferFormValue$2<FieldDefUnion<T>[]>;
 };
 /** Union type for items that can be passed to provideDynamicForm */
-type FieldTypeOrFeature = FieldTypeDefinition | WrapperTypeDefinition | WrappersBundle | DynamicFormFeature;
+type FieldTypeOrFeature = FieldTypeDefinition | WrapperTypeDefinition$1 | WrappersBundle | DynamicFormFeature;
 /** Extract only FieldTypeDefinition items from a tuple type */
-type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = {
-    [K in keyof T]: T[K] extends FieldTypeDefinition ? T[K] : never;
-}[number] extends infer U ? U extends FieldTypeDefinition ? U[] : never : never;
+type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = { [K in keyof T]: T[K] extends FieldTypeDefinition ? T[K] : never; }[number] extends (infer U) ? U extends FieldTypeDefinition ? U[] : never : never;
 /**
  * Provider function to configure the dynamic form system with field types and options.
  *
@@ -480,33 +492,31 @@ type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = {
  * @returns Environment providers for dependency injection with type inference
  * @typeParam T - Array of field type definitions for type inference
  */
-declare function provideDynamicForm<const T extends FieldTypeOrFeature[]>(...items: T): ProvideDynamicFormResult<ExtractFieldTypes<T> extends FieldTypeDefinition[] ? ExtractFieldTypes<T> : FieldTypeDefinition[]>;
+export declare function provideDynamicForm<const T extends FieldTypeOrFeature[]>(...items: T): ProvideDynamicFormResult<ExtractFieldTypes<T> extends FieldTypeDefinition[] ? ExtractFieldTypes<T> : FieldTypeDefinition[]>;
 /** Extract FieldDef types from provider result */
 type ExtractFieldDefs<T> = T extends {
-    __fieldDefs?: infer F;
+  __fieldDefs?: infer F;
 } ? F : never;
 /** Extract form value type from provider result */
 type ExtractFormValue<T> = T extends {
-    __formValue?: infer V;
+  __formValue?: infer V;
 } ? V : never;
-
 /** Built-in field types provided by the dynamic form library. */
-declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
-
+export declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
 /** Configuration options for the logger feature. */
 interface LoggerConfigOptions {
-    /**
-     * Whether general logging is enabled.
-     *
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * Derivation logging level.
-     *
-     * @default 'none'
-     */
-    derivations?: DerivationLogLevel;
+  /**
+   * Whether general logging is enabled.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Derivation logging level.
+   *
+   * @default 'none'
+   */
+  derivations?: DerivationLogLevel;
 }
 /**
  * Configure logging for dynamic forms.
@@ -514,17 +524,15 @@ interface LoggerConfigOptions {
  * @param config - Boolean to enable/disable logging, a function returning boolean, or a config object
  * @returns A DynamicFormFeature that configures logging
  */
-declare function withLoggerConfig(config?: boolean | (() => boolean) | LoggerConfigOptions): DynamicFormFeature<'logger'>;
-
+export declare function withLoggerConfig(config?: boolean | (() => boolean) | LoggerConfigOptions): DynamicFormFeature<'logger'>;
 /** Console-based logger implementation. */
-declare class ConsoleLogger implements Logger {
-    private readonly prefix;
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
+export declare class ConsoleLogger implements Logger$1 {
+  private readonly prefix;
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
 }
-
 /**
  * Enables automatic form value attachment to all events dispatched through the EventBus.
  *
@@ -537,8 +545,7 @@ declare class ConsoleLogger implements Logger {
  * 5. No global feature - Disabled globally (default)
  * @returns A DynamicFormFeature that enables form value attachment to events
  */
-declare function withEventFormValue(): DynamicFormFeature<'event-form-value'>;
-
+export declare function withEventFormValue(): DynamicFormFeature<'event-form-value'>;
 /**
  * Configures global value exclusion defaults for form submission output.
  *
@@ -551,8 +558,7 @@ declare function withEventFormValue(): DynamicFormFeature<'event-form-value'>;
  * @param config - Partial override of exclusion rules. Unspecified properties default to `true`.
  * @returns A DynamicFormFeature that configures value exclusion defaults
  */
-declare function withValueExclusionDefaults(config?: Partial<ValueExclusionConfig>): DynamicFormFeature<'value-exclusion'>;
-
+export declare function withValueExclusionDefaults(config?: Partial<ValueExclusionConfig$1>): DynamicFormFeature<'value-exclusion'>;
 /**
  * Configures the global page preload window for paged forms — how many pages on
  * each side of the current page are mounted during browser idle time.
@@ -582,14 +588,12 @@ declare function withValueExclusionDefaults(config?: Partial<ValueExclusionConfi
  * provideDynamicForm(...withMaterialFields(), withPagePreload(2));
  * ```
  */
-declare function withPagePreload(window: number): DynamicFormFeature<'page-preload'>;
-
+export declare function withPagePreload(window: number): DynamicFormFeature<'page-preload'>;
 /** Per-form override shape for parking. `false` opts out; an object tunes the margin. */
 type FieldParkingOption = boolean | {
-    /** IntersectionObserver root margin. Supports one to four `px` or `%` values. */
-    margin?: string;
+  /** IntersectionObserver root margin. Supports one to four `px` or `%` values. */
+  margin?: string;
 };
-
 /**
  * Configures global progressive field mounting ("field windowing") for large
  * flat (single-page) forms.
@@ -628,12 +632,11 @@ type FieldParkingOption = boolean | {
  * provideDynamicForm(...withMaterialFields(), withFieldWindowing({ eager: 20 }));
  * ```
  */
-declare function withFieldWindowing(config?: {
-    eager?: number;
-    placeholderHeight?: string;
-    park?: FieldParkingOption;
+export declare function withFieldWindowing(config?: {
+  eager?: number;
+  placeholderHeight?: string;
+  park?: FieldParkingOption;
 }): DynamicFormFeature<'field-windowing'>;
-
 /**
  * Enables WebMCP tool registration for forms that declare `options.webMcp`.
  *
@@ -676,8 +679,7 @@ declare function withFieldWindowing(config?: {
  * } as const satisfies FormConfig;
  * ```
  */
-declare function withExperimentalWebMcp(): DynamicFormFeature<'web-mcp'>;
-
+export declare function withExperimentalWebMcp(): DynamicFormFeature<'web-mcp'>;
 /**
  * What the WebMCP layer is currently doing for this form. Reported by
  * `DynamicForm.webMcpStatus()`; `'active'` is the only state in which an agent
@@ -685,20 +687,19 @@ declare function withExperimentalWebMcp(): DynamicFormFeature<'web-mcp'>;
  *
  * @experimental
  */
-type WebMcpStatus = 
+type WebMcpStatus =
 /** `withExperimentalWebMcp()` is not provided, or this is the server. */
-'disabled'
+'disabled' |
 /** Enabled, but the current config does not declare `options.webMcp`. */
- | 'idle'
+'idle' |
 /** Loading the registrar or awaiting `registerTool()`. */
- | 'registering'
+'registering' |
 /** Tools are registered against the browser's model context. */
- | 'active'
+'active' |
 /** The browser exposes no model context, so there is nothing to register against. */
- | 'unsupported'
+'unsupported' |
 /** Registration was attempted and rejected. See the console for the reason. */
- | 'failed';
-
+'failed';
 /**
  * How a submission ended.
  *
@@ -713,36 +714,36 @@ type WebMcpStatus =
  * @experimental
  */
 type SubmissionOutcome = {
-    readonly status: 'success';
-}
+  readonly status: 'success';
+} |
 /** No `submission.action` is configured; the `(submitted)` output received the value. */
- | {
-    readonly status: 'dispatched';
-}
+{
+  readonly status: 'dispatched';
+} |
 /** The form was invalid, so nothing was submitted. */
- | {
-    readonly status: 'validation-failed';
-}
+{
+  readonly status: 'validation-failed';
+} |
 /** Async validators had not resolved, so submission was skipped. */
- | {
-    readonly status: 'pending-validation';
-}
+{
+  readonly status: 'pending-validation';
+} |
 /** The action ran and came back with server-side validation errors. */
- | {
-    readonly status: 'server-errors';
-}
+{
+  readonly status: 'server-errors';
+} |
 /** The action threw or rejected. */
- | {
-    readonly status: 'action-failed';
-    readonly error: unknown;
-}
+{
+  readonly status: 'action-failed';
+  readonly error: unknown;
+} |
 /** Another submission was already in flight and this one was dropped. */
- | {
-    readonly status: 'busy';
-}
+{
+  readonly status: 'busy';
+} |
 /** The form went away before the submission settled. */
- | {
-    readonly status: 'cancelled';
+{
+  readonly status: 'cancelled';
 };
 /**
  * The reply channel a caller attaches to `FormSubmitEvent` when it needs to know
@@ -757,12 +758,11 @@ type SubmissionOutcome = {
  * @experimental
  */
 interface SubmissionReply {
-    /** Marks the submission as taken by the pipeline. */
-    accept(): void;
-    /** Reports the final outcome. The first call wins; later calls are ignored. */
-    settle(outcome: SubmissionOutcome): void;
+  /** Marks the submission as taken by the pipeline. */
+  accept(): void;
+  /** Reports the final outcome. The first call wins; later calls are ignored. */
+  settle(outcome: SubmissionOutcome): void;
 }
-
 /**
  * Configures global validation execution defaults — when validators should run
  * relative to a field's reactive state.
@@ -777,8 +777,7 @@ interface SubmissionReply {
  * @param config - Partial override. Unspecified properties keep their defaults.
  * @returns A `DynamicFormFeature` that configures validation execution defaults.
  */
-declare function withValidationExecutionDefaults(config?: Partial<ValidationExecutionConfig>): DynamicFormFeature<'validation-execution'>;
-
+export declare function withValidationExecutionDefaults(config?: Partial<ValidationExecutionConfig$1>): DynamicFormFeature<'validation-execution'>;
 /**
  * Opt into Angular Signal Forms' legacy `.ng-touched` / `.ng-invalid` /
  * `.ng-dirty` / `.ng-pristine` / `.ng-untouched` / `.ng-pending` /
@@ -786,80 +785,112 @@ declare function withValidationExecutionDefaults(config?: Partial<ValidationExec
  *
  * @returns A DynamicFormFeature that enables the legacy `ng-*` class strategy
  */
-declare function withLegacyStatusClasses(): DynamicFormFeature<'legacy-status-classes'>;
-
+export declare function withLegacyStatusClasses(): DynamicFormFeature<'legacy-status-classes'>;
 /** Zero-cost type carrier used in wrapper registrations. */
-declare function wrapperProps<T>(): T;
-
+export declare function wrapperProps<T>(): T;
 /**
  * Marks an `<ng-template>` projected into `<df-dynamic-form>` content as
  * available to template addons by name.
  */
-declare class DfTemplate {
-    /** Name this template registers under — referenced from `TemplateAddon.templateKey`. */
-    readonly dfTemplate: _angular_core.InputSignal<string>;
-    /** The wrapped template, captured for registration and `NgTemplateOutlet` rendering. */
-    readonly templateRef: TemplateRef<unknown>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DfTemplate, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DfTemplate, "ng-template[dfTemplate]", ["dfTemplate"], { "dfTemplate": { "alias": "dfTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class DfTemplate {
+  /** Name this template registers under — referenced from `TemplateAddon.templateKey`. */
+  readonly dfTemplate: import("@angular/core").InputSignal<string>;
+  /** The wrapped template, captured for registration and `NgTemplateOutlet` rendering. */
+  readonly templateRef: TemplateRef<unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DfTemplate, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<DfTemplate, "ng-template[dfTemplate]", ["dfTemplate"], {
+    "dfTemplate": {
+      "alias": "dfTemplate";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
 /** Renderer for the universal `text` addon type. */
-declare class TextAddonComponent {
-    readonly addon: _angular_core.InputSignal<TextAddon>;
-    /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
-    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextAddonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextAddonComponent, "df-text-addon", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class TextAddonComponent {
+  readonly addon: import("@angular/core").InputSignal<TextAddon$1>;
+  /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
+  readonly fieldInputs: import("@angular/core").InputSignal<WrapperFieldInputs | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TextAddonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TextAddonComponent, "df-text-addon", never, {
+    "addon": {
+      "alias": "addon";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldInputs": {
+      "alias": "fieldInputs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
 /** Renderer for the universal `template` addon type. */
-declare class TemplateAddonComponent {
-    private readonly templates;
-    private readonly logger;
-    readonly addon: _angular_core.InputSignal<TemplateAddon>;
-    /** Forwarded by `df-addon-slot`; surfaced to the template as its implicit `$implicit` context. */
-    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
-    protected readonly template: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
-    /** Implicit context payload — template authors bind via `let-fi`. */
-    protected readonly outletContext: _angular_core.Signal<{
-        $implicit: WrapperFieldInputs | undefined;
-    }>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateAddonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TemplateAddonComponent, "df-template-addon", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class TemplateAddonComponent {
+  private readonly templates;
+  private readonly logger;
+  readonly addon: import("@angular/core").InputSignal<TemplateAddon$1>;
+  /** Forwarded by `df-addon-slot`; surfaced to the template as its implicit `$implicit` context. */
+  readonly fieldInputs: import("@angular/core").InputSignal<WrapperFieldInputs | undefined>;
+  protected readonly template: import("@angular/core").Signal<import("@angular/core").TemplateRef<unknown> | null>;
+  /** Implicit context payload — template authors bind via `let-fi`. */
+  protected readonly outletContext: import("@angular/core").Signal<{
+    $implicit: WrapperFieldInputs | undefined;
+  }>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<TemplateAddonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TemplateAddonComponent, "df-template-addon", never, {
+    "addon": {
+      "alias": "addon";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldInputs": {
+      "alias": "fieldInputs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
 /**
  * Renderer for the universal `component` addon type.
  *
  * @codeOnly The `component` loader is a function; this kind is dropped in
  * lenient validation when the config originated from JSON.
  */
-declare class ComponentAddonComponent {
-    private readonly logger;
-    readonly addon: _angular_core.InputSignal<ComponentAddon>;
-    /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
-    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
-    protected readonly inputs: _angular_core.Signal<Record<string, unknown>>;
-    /**
-     * Latest async-loaded `{ addon, component }` pair. Tagging the result with
-     * its source addon lets `resolvedComponent` filter stale loads structurally
-     * — same kind-tagging pattern `DfAddonSlot` uses. When `addon` swaps
-     * mid-load, the prior loader still completes and writes here, but the
-     * computed ignores it because the recorded addon no longer matches the
-     * current one.
-     */
-    private readonly asyncLoaded;
-    protected readonly resolvedComponent: _angular_core.Signal<Type<unknown> | undefined>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentAddonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComponentAddonComponent, "df-component-addon", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class ComponentAddonComponent {
+  private readonly logger;
+  readonly addon: import("@angular/core").InputSignal<ComponentAddon$1>;
+  /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
+  readonly fieldInputs: import("@angular/core").InputSignal<WrapperFieldInputs | undefined>;
+  protected readonly inputs: import("@angular/core").Signal<Record<string, unknown>>;
+  /**
+   * Latest async-loaded `{ addon, component }` pair. Tagging the result with
+   * its source addon lets `resolvedComponent` filter stale loads structurally
+   * — same kind-tagging pattern `DfAddonSlot` uses. When `addon` swaps
+   * mid-load, the prior loader still completes and writes here, but the
+   * computed ignores it because the recorded addon no longer matches the
+   * current one.
+   */
+  private readonly asyncLoaded;
+  protected readonly resolvedComponent: import("@angular/core").Signal<Type<unknown> | undefined>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<ComponentAddonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ComponentAddonComponent, "df-component-addon", never, {
+    "addon": {
+      "alias": "addon";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldInputs": {
+      "alias": "fieldInputs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
 /** Register a custom addon type with the form. */
-declare function withCustomAddon<T extends BaseAddon>(definition: AddonTypeDefinition<T>): DynamicFormFeature<'addons'>;
-
+export declare function withCustomAddon<T extends BaseAddon$1>(definition: AddonTypeDefinition$1<T>): DynamicFormFeature<'addons'>;
 /**
  * Typed feature returned by {@link withAddonActions}. Carries the
  * registered handler keys as a phantom type so consumers can derive the
@@ -867,67 +898,65 @@ declare function withCustomAddon<T extends BaseAddon>(definition: AddonTypeDefin
  * every key.
  */
 type AddonActionsFeature<K extends string = string> = DynamicFormFeature<'addon-actions'> & {
-    /** @internal Phantom field carrying the registered keys; never read at runtime. */
-    readonly __handlerKeys?: K;
+  /** @internal Phantom field carrying the registered keys; never read at runtime. */
+  readonly __handlerKeys?: K;
 };
 /** Register named action handlers reachable via JSON-driven addon configs. */
-declare function withAddonActions<const H extends Record<string, AddonActionHandler>>(handlers: H): AddonActionsFeature<keyof H & string>;
-
+export declare function withAddonActions<const H extends Record<string, AddonActionHandler>>(handlers: H): AddonActionsFeature<keyof H & string>;
 /** Reason an addon was dropped during validation. */
 type AddonWarning = {
-    type: 'unknown-field-type';
-    fieldKey: string;
-    fieldType: string;
+  type: 'unknown-field-type';
+  fieldKey: string;
+  fieldType: string;
 } | {
-    type: 'field-type-no-addon-support';
-    fieldKey: string;
-    fieldType: string;
+  type: 'field-type-no-addon-support';
+  fieldKey: string;
+  fieldType: string;
 } | {
-    type: 'unknown-slot';
-    fieldKey: string;
-    fieldType: string;
-    slot: string;
-    allowedSlots: readonly string[];
+  type: 'unknown-slot';
+  fieldKey: string;
+  fieldType: string;
+  slot: string;
+  allowedSlots: readonly string[];
 } | {
-    type: 'unknown-type';
-    fieldKey: string;
-    addonType: string;
-    registeredTypes: readonly string[];
+  type: 'unknown-type';
+  fieldKey: string;
+  addonType: string;
+  registeredTypes: readonly string[];
 } | {
-    type: 'type-not-allowed';
-    fieldKey: string;
-    fieldType: string;
-    addonType: string;
-    allowedTypes: readonly string[];
+  type: 'type-not-allowed';
+  fieldKey: string;
+  fieldType: string;
+  addonType: string;
+  allowedTypes: readonly string[];
 } | {
-    type: 'shape-violation';
-    fieldKey: string;
-    addonType: string;
-    reason: string;
+  type: 'shape-violation';
+  fieldKey: string;
+  addonType: string;
+  reason: string;
 } | {
-    type: 'code-only-type-in-json';
-    fieldKey: string;
-    addonType: string;
+  type: 'code-only-type-in-json';
+  fieldKey: string;
+  addonType: string;
 } | {
-    type: 'code-only-action-in-json';
-    fieldKey: string;
-    reason: string;
+  type: 'code-only-action-in-json';
+  fieldKey: string;
+  reason: string;
 };
-
 /** Options accepted by {@link sanitizeFormConfig}. */
 interface SanitizeFormConfigOptions {
-    /**
-     * Whether the config originated from JSON (server-driven) or inline
-     * TypeScript code.
-     */
-    source?: 'json' | 'inline';
+  /**
+   * Whether the config originated from JSON (server-driven) or inline
+   * TypeScript code.
+   */
+  source?: 'json' | 'inline';
 }
 /** Result of a `sanitizeFormConfig` call. */
 interface SanitizedFormConfig {
-    /** Sanitized config — invalid addons stripped from the field tree. */
-    sanitized: FormConfig;
-    /** Structured list of every addon that was dropped, and why. */
-    warnings: readonly AddonWarning[];
+  /** Sanitized config — invalid addons stripped from the field tree. */
+  sanitized: FormConfig$1;
+  /** Structured list of every addon that was dropped, and why. */
+  warnings: readonly AddonWarning[];
 }
 /**
  * Walk a `FormConfig`, validate every field's addons against the active
@@ -946,19 +975,18 @@ interface SanitizedFormConfig {
  * }
  * ```
  */
-declare function sanitizeFormConfig(config: FormConfig, options?: SanitizeFormConfigOptions): SanitizedFormConfig;
-
+export declare function sanitizeFormConfig(config: FormConfig$1, options?: SanitizeFormConfigOptions): SanitizedFormConfig;
 /** Per-dispatch overrides for a page jump. */
 interface PageNavigationOptions {
-    /**
-     * Whether to apply the forward-jump validity gate.
-     *
-     * Set `false` to land on the target regardless of earlier pages, which is what
-     * restoring a saved session wants. Bounds and hidden-page checks still apply.
-     *
-     * @default true
-     */
-    validate?: boolean;
+  /**
+   * Whether to apply the forward-jump validity gate.
+   *
+   * Set `false` to land on the target regardless of earlier pages, which is what
+   * restoring a saved session wants. Bounds and hidden-page checks still apply.
+   *
+   * @default true
+   */
+  validate?: boolean;
 }
 /**
  * Event dispatched to move a paged form to a specific page.
@@ -968,19 +996,18 @@ interface PageNavigationOptions {
  * if one is invalid, navigation stops on the first invalid page. Pass
  * `{ validate: false }` to skip that gate and land on the target.
  */
-declare class GoToPageEvent implements FormEvent {
-    /** The target page index (0-based) */
-    readonly pageIndex: number;
-    /** Per-dispatch overrides; omit for the default gated behavior. */
-    readonly options?: PageNavigationOptions | undefined;
-    readonly type: "go-to-page";
-    constructor(
-    /** The target page index (0-based) */
-    pageIndex: number, 
-    /** Per-dispatch overrides; omit for the default gated behavior. */
-    options?: PageNavigationOptions | undefined);
+export declare class GoToPageEvent implements FormEvent$1 {
+  /** The target page index (0-based) */
+  readonly pageIndex: number;
+  /** Per-dispatch overrides; omit for the default gated behavior. */
+  readonly options?: PageNavigationOptions | undefined;
+  readonly type: "go-to-page";
+  constructor(
+  /** The target page index (0-based) */
+  pageIndex: number,
+  /** Per-dispatch overrides; omit for the default gated behavior. */
+  options?: PageNavigationOptions | undefined);
 }
-
 /**
  * Event dispatched to submit the form (the action behind a `submit` button).
  *
@@ -988,249 +1015,235 @@ declare class GoToPageEvent implements FormEvent {
  * {@link SubmissionReply}; the submission handler reports back through it. A
  * button click passes nothing and stays fire-and-forget, as before.
  */
-declare class FormSubmitEvent implements FormEvent {
-    readonly reply?: SubmissionReply | undefined;
-    readonly type: "submit";
-    constructor(reply?: SubmissionReply | undefined);
+export declare class FormSubmitEvent implements FormEvent$1 {
+  readonly reply?: SubmissionReply | undefined;
+  readonly type: "submit";
+  constructor(reply?: SubmissionReply | undefined);
 }
-
 /** Event dispatched to advance a paged form to the next page. */
-declare class NextPageEvent implements FormEvent {
-    readonly type: "next-page";
+export declare class NextPageEvent implements FormEvent$1 {
+  readonly type: "next-page";
 }
-
 /** Event dispatched to return a paged form to the previous page. */
-declare class PreviousPageEvent implements FormEvent {
-    readonly type: "previous-page";
+export declare class PreviousPageEvent implements FormEvent$1 {
+  readonly type: "previous-page";
 }
-
 /**
  * Template type for array items used in events.
  * Canonical definition lives in {@link ArrayItemDefinition} — this alias
  * preserves the events-specific naming convention.
  */
 type ArrayItemDefinitionTemplate = ArrayItemDefinition;
-
 /**
  * Event dispatched to append a new item at the END of an array field.
  *
  * @typeParam TTemplate - The type of the template (single field or array of fields)
  */
-declare class AppendArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent {
-    /** The key of the array field to append an item to */
-    readonly arrayKey: string;
-    /**
-     * Template for the new array item. REQUIRED.
-     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
-     */
-    readonly template: TTemplate;
-    readonly type: "append-array-item";
-    constructor(
-    /** The key of the array field to append an item to */
-    arrayKey: string, 
-    /**
-     * Template for the new array item. REQUIRED.
-     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
-     */
-    template: TTemplate);
+export declare class AppendArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent$1 {
+  /** The key of the array field to append an item to */
+  readonly arrayKey: string;
+  /**
+   * Template for the new array item. REQUIRED.
+   * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+   */
+  readonly template: TTemplate;
+  readonly type: "append-array-item";
+  constructor(
+  /** The key of the array field to append an item to */
+  arrayKey: string,
+  /**
+   * Template for the new array item. REQUIRED.
+   * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+   */
+  template: TTemplate);
 }
-
 /**
  * Event dispatched to prepend a new item at the BEGINNING of an array field.
  *
  * @typeParam TTemplate - The type of the template (single field or array of fields)
  */
-declare class PrependArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent {
-    /** The key of the array field to prepend an item to */
-    readonly arrayKey: string;
-    /**
-     * Template for the new array item. REQUIRED.
-     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
-     */
-    readonly template: TTemplate;
-    readonly type: "prepend-array-item";
-    constructor(
-    /** The key of the array field to prepend an item to */
-    arrayKey: string, 
-    /**
-     * Template for the new array item. REQUIRED.
-     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
-     */
-    template: TTemplate);
+export declare class PrependArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent$1 {
+  /** The key of the array field to prepend an item to */
+  readonly arrayKey: string;
+  /**
+   * Template for the new array item. REQUIRED.
+   * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+   */
+  readonly template: TTemplate;
+  readonly type: "prepend-array-item";
+  constructor(
+  /** The key of the array field to prepend an item to */
+  arrayKey: string,
+  /**
+   * Template for the new array item. REQUIRED.
+   * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+   */
+  template: TTemplate);
 }
-
 /**
  * Event dispatched to insert a new item at a SPECIFIC INDEX in an array field.
  *
  * @typeParam TTemplate - The type of the template (single field or array of fields)
  */
-declare class InsertArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent {
-    /** The key of the array field to insert an item into */
-    readonly arrayKey: string;
-    /** The index at which to insert the new item */
-    readonly index: number;
-    /**
-     * Template for the new array item. REQUIRED.
-     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
-     */
-    readonly template: TTemplate;
-    readonly type: "insert-array-item";
-    constructor(
-    /** The key of the array field to insert an item into */
-    arrayKey: string, 
-    /** The index at which to insert the new item */
-    index: number, 
-    /**
-     * Template for the new array item. REQUIRED.
-     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
-     */
-    template: TTemplate);
+export declare class InsertArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent$1 {
+  /** The key of the array field to insert an item into */
+  readonly arrayKey: string;
+  /** The index at which to insert the new item */
+  readonly index: number;
+  /**
+   * Template for the new array item. REQUIRED.
+   * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+   */
+  readonly template: TTemplate;
+  readonly type: "insert-array-item";
+  constructor(
+  /** The key of the array field to insert an item into */
+  arrayKey: string,
+  /** The index at which to insert the new item */
+  index: number,
+  /**
+   * Template for the new array item. REQUIRED.
+   * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+   */
+  template: TTemplate);
 }
-
 /** Event dispatched to remove the LAST item from an array field. */
-declare class PopArrayItemEvent implements FormEvent {
-    /** The key of the array field to remove the last item from */
-    readonly arrayKey: string;
-    readonly type: "pop-array-item";
-    constructor(
-    /** The key of the array field to remove the last item from */
-    arrayKey: string);
+export declare class PopArrayItemEvent implements FormEvent$1 {
+  /** The key of the array field to remove the last item from */
+  readonly arrayKey: string;
+  readonly type: "pop-array-item";
+  constructor(
+  /** The key of the array field to remove the last item from */
+  arrayKey: string);
 }
-
 /** Event dispatched to remove the FIRST item from an array field. */
-declare class ShiftArrayItemEvent implements FormEvent {
-    /** The key of the array field to remove the first item from */
-    readonly arrayKey: string;
-    readonly type: "shift-array-item";
-    constructor(
-    /** The key of the array field to remove the first item from */
-    arrayKey: string);
+export declare class ShiftArrayItemEvent implements FormEvent$1 {
+  /** The key of the array field to remove the first item from */
+  readonly arrayKey: string;
+  readonly type: "shift-array-item";
+  constructor(
+  /** The key of the array field to remove the first item from */
+  arrayKey: string);
 }
-
 /** Event dispatched to move an existing item from one index to another within an array field. */
-declare class MoveArrayItemEvent implements FormEvent {
-    /** The key of the array field containing the item to move */
-    readonly arrayKey: string;
-    /** The current index of the item to move */
-    readonly fromIndex: number;
-    /** The target index to move the item to */
-    readonly toIndex: number;
-    readonly type: "move-array-item";
-    constructor(
-    /** The key of the array field containing the item to move */
-    arrayKey: string, 
-    /** The current index of the item to move */
-    fromIndex: number, 
-    /** The target index to move the item to */
-    toIndex: number);
+export declare class MoveArrayItemEvent implements FormEvent$1 {
+  /** The key of the array field containing the item to move */
+  readonly arrayKey: string;
+  /** The current index of the item to move */
+  readonly fromIndex: number;
+  /** The target index to move the item to */
+  readonly toIndex: number;
+  readonly type: "move-array-item";
+  constructor(
+  /** The key of the array field containing the item to move */
+  arrayKey: string,
+  /** The current index of the item to move */
+  fromIndex: number,
+  /** The target index to move the item to */
+  toIndex: number);
 }
-
 /** Event dispatched to remove an item at a SPECIFIC INDEX from an array field. */
-declare class RemoveAtIndexEvent implements FormEvent {
-    /** The key of the array field to remove an item from */
-    readonly arrayKey: string;
-    /** The index of the item to remove */
-    readonly index: number;
-    readonly type: "remove-at-index";
-    constructor(
-    /** The key of the array field to remove an item from */
-    arrayKey: string, 
-    /** The index of the item to remove */
-    index: number);
+export declare class RemoveAtIndexEvent implements FormEvent$1 {
+  /** The key of the array field to remove an item from */
+  readonly arrayKey: string;
+  /** The index of the item to remove */
+  readonly index: number;
+  readonly type: "remove-at-index";
+  constructor(
+  /** The key of the array field to remove an item from */
+  arrayKey: string,
+  /** The index of the item to remove */
+  index: number);
 }
-
 /**
  * Builder for array manipulation events.
  *
  * @param arrayKey - The key of the array field to operate on
  * @returns An object with methods for all 7 array operations
  */
-declare function arrayEvent(arrayKey: string): {
-    /**
-     * Append a new item at the END of the array.
-     * This is the most common operation for adding items.
-     *
-     * @param template - Template for the new item (REQUIRED)
-     *   - Single field: Creates a primitive item (field's value is extracted directly)
-     *   - Array of fields: Creates an object item (fields merged into object)
-     * @returns An AppendArrayItemEvent to dispatch
-     */
-    append: <T extends ArrayItemDefinitionTemplate>(template: T) => AppendArrayItemEvent<T>;
-    /**
-     * Prepend a new item at the BEGINNING of the array.
-     * Use when new items should appear at the start.
-     *
-     * @param template - Template for the new item (REQUIRED)
-     *   - Single field: Creates a primitive item (field's value is extracted directly)
-     *   - Array of fields: Creates an object item (fields merged into object)
-     * @returns A PrependArrayItemEvent to dispatch
-     */
-    prepend: <T extends ArrayItemDefinitionTemplate>(template: T) => PrependArrayItemEvent<T>;
-    /**
-     * Insert a new item at a SPECIFIC INDEX in the array.
-     * Use when you need precise control over item placement.
-     *
-     * @param index - The position at which to insert the new item
-     * @param template - Template for the new item (REQUIRED)
-     *   - Single field: Creates a primitive item (field's value is extracted directly)
-     *   - Array of fields: Creates an object item (fields merged into object)
-     * @returns An InsertArrayItemEvent to dispatch
-     */
-    insertAt: <T extends ArrayItemDefinitionTemplate>(index: number, template: T) => InsertArrayItemEvent<T>;
-    /**
-     * Remove the LAST item from the array.
-     * Equivalent to JavaScript's `Array.pop()`.
-     *
-     * @returns A PopArrayItemEvent to dispatch
-     */
-    pop: () => PopArrayItemEvent;
-    /**
-     * Remove the FIRST item from the array.
-     * Equivalent to JavaScript's `Array.shift()`.
-     *
-     * @returns A ShiftArrayItemEvent to dispatch
-     */
-    shift: () => ShiftArrayItemEvent;
-    /**
-     * Remove an item at a SPECIFIC INDEX from the array.
-     * Use when you need to remove a specific item by position.
-     *
-     * @param index - The position of the item to remove
-     * @returns A RemoveAtIndexEvent to dispatch
-     */
-    removeAt: (index: number) => RemoveAtIndexEvent;
-    /**
-     * Move an existing item from one position to another within the array.
-     * This is an atomic reorder — the item is NOT destroyed and recreated.
-     * The resolved component, form value, and stored template are preserved.
-     *
-     * @param from - The current index of the item to move
-     * @param to - The target index to move the item to
-     * @returns A MoveArrayItemEvent to dispatch
-     */
-    move: (from: number, to: number) => MoveArrayItemEvent;
+export declare function arrayEvent(arrayKey: string): {
+  /**
+   * Append a new item at the END of the array.
+   * This is the most common operation for adding items.
+   *
+   * @param template - Template for the new item (REQUIRED)
+   *   - Single field: Creates a primitive item (field's value is extracted directly)
+   *   - Array of fields: Creates an object item (fields merged into object)
+   * @returns An AppendArrayItemEvent to dispatch
+   */
+  append: <T extends ArrayItemDefinitionTemplate>(template: T) => AppendArrayItemEvent<T>;
+  /**
+   * Prepend a new item at the BEGINNING of the array.
+   * Use when new items should appear at the start.
+   *
+   * @param template - Template for the new item (REQUIRED)
+   *   - Single field: Creates a primitive item (field's value is extracted directly)
+   *   - Array of fields: Creates an object item (fields merged into object)
+   * @returns A PrependArrayItemEvent to dispatch
+   */
+  prepend: <T extends ArrayItemDefinitionTemplate>(template: T) => PrependArrayItemEvent<T>;
+  /**
+   * Insert a new item at a SPECIFIC INDEX in the array.
+   * Use when you need precise control over item placement.
+   *
+   * @param index - The position at which to insert the new item
+   * @param template - Template for the new item (REQUIRED)
+   *   - Single field: Creates a primitive item (field's value is extracted directly)
+   *   - Array of fields: Creates an object item (fields merged into object)
+   * @returns An InsertArrayItemEvent to dispatch
+   */
+  insertAt: <T extends ArrayItemDefinitionTemplate>(index: number, template: T) => InsertArrayItemEvent<T>;
+  /**
+   * Remove the LAST item from the array.
+   * Equivalent to JavaScript's `Array.pop()`.
+   *
+   * @returns A PopArrayItemEvent to dispatch
+   */
+  pop: () => PopArrayItemEvent;
+  /**
+   * Remove the FIRST item from the array.
+   * Equivalent to JavaScript's `Array.shift()`.
+   *
+   * @returns A ShiftArrayItemEvent to dispatch
+   */
+  shift: () => ShiftArrayItemEvent;
+  /**
+   * Remove an item at a SPECIFIC INDEX from the array.
+   * Use when you need to remove a specific item by position.
+   *
+   * @param index - The position of the item to remove
+   * @returns A RemoveAtIndexEvent to dispatch
+   */
+  removeAt: (index: number) => RemoveAtIndexEvent;
+  /**
+   * Move an existing item from one position to another within the array.
+   * This is an atomic reorder — the item is NOT destroyed and recreated.
+   * The resolved component, form value, and stored template are preserved.
+   *
+   * @param from - The current index of the item to move
+   * @param to - The target index to move the item to
+   * @returns A MoveArrayItemEvent to dispatch
+   */
+  move: (from: number, to: number) => MoveArrayItemEvent;
 };
-
 /**
  * Context object for array item operations (add/remove)
  * Provides the necessary information to resolve tokens in array item event arguments
  */
 interface ArrayItemContext {
-    /** The key of the field */
-    key: string;
-    /** Array index for the item */
-    index?: number;
-    /** Parent array field key */
-    arrayKey?: string;
-    /** Form value for token resolution */
-    formValue?: unknown;
+  /** The key of the field */
+  key: string;
+  /** Array index for the item */
+  index?: number;
+  /** Parent array field key */
+  arrayKey?: string;
+  /** Form value for token resolution */
+  formValue?: unknown;
 }
-
-export { ActivePageInitializedEvent, AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DfTemplate, DynamicForm, EventDispatcher, FormClearEvent, FormResetEvent, FormSubmitEvent, GoToPageEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, PageChangeEvent, PagerStateEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createWrappers, isWrappersBundle, provideDynamicForm, sanitizeFormConfig, withAddonActions, withCustomAddon, withEventFormValue, withExperimentalWebMcp, withFieldWindowing, withLegacyStatusClasses, withLoggerConfig, withPagePreload, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
-export type { AddonActionsFeature, AddonWarning, ArrayItemContext, ArrayItemDefinitionTemplate, ExtractFieldDefs, ExtractFormValue, FieldParkingOption, InferWrapperRegistry, PageNavigationOptions, PagerState, SanitizeFormConfigOptions, SanitizedFormConfig, SubmissionOutcome, SubmissionReply, WebMcpStatus, WrapperRegistration, WrappersBundle };
+export { type AddonActionContext, type AddonActionPreset, type AddonActionsFeature, type AddonSlot, type AddonTypeDefinition, type AddonWarning, type AnyAddon, type ArrayAllowedChildren, type ArrayButtonConfig, type ArrayField, type ArrayItemContext, type ArrayItemDefinitionTemplate, type ArrayItemTemplate, type AsyncCondition, type AsyncConditionFunction, type AsyncCustomValidator, type AsyncDerivationFunction, type AsyncValidatorConfig, type AvailableFieldTypes, type BaseAddon, type BaseCheckedField, type BaseValidatorConfig, type BaseValueField, type BuiltInValidatorConfig, type CheckedFieldComponent, type CommonAddonActionPreset, type CommonAddonSlot, type ComponentAddon, type ConditionalExpression, type ContainerAllowedChildren, type ContainerField, type ContainerFieldTypes, type CssWrapper, type CustomFnConfig, type CustomFunction, type CustomValidator, type CustomValidatorConfig, DF_FIELD_TEMPLATES, type DeclarativeHttpValidatorConfig, type DynamicFormActionRegistry, type DynamicFormAddonActionPresetRegistry, type DynamicFormAddonRegistry, type DynamicFormAddonSlotRegistry, DynamicFormError, type DynamicFormFieldRegistry, DynamicFormLogger, type DynamicText, type DynamicValue, type EvaluationContext, type ExtractField, type ExtractFieldDefs, type ExtractFormValue, type FieldBoundAddonActionContext, type FieldComponent, type FieldDef, type FieldMeta, type FieldOption, type FieldParkingOption, type FieldPathAccess, type FieldRegistryContainers, type FieldRegistryLeaves, type FieldRegistryWrappers, type FieldWithValidation, type FieldWrapper, type FormConfig, type FormEvent, type FormEventConstructor, type FormMode, type FormModeDetectionResult, type FormOptions, type FormStateCondition, type GroupAllowedChildren, type GroupField, type HiddenField, type HiddenScalar, type HiddenValue, type HttpCondition, type HttpCustomValidator, type HttpRequestConfig, type HttpValidationResponseMapping, type InferFormValue, type InferWrapperRegistry, type InitialPageConfig, type LeafFieldTypes, type Logger, type LogicConfig, type NarrowField, type NarrowFields, type NextButtonOptions, NoopLogger, type OrphanAddonActionContext, type PageAllowedChildren, type PageField, type PageNavigationOptions, type PagerState, type RegisteredActionRef, type RegisteredFieldTypes, type ResolvedValidationExecutionConfig, type ResolvedValueExclusionConfig, type RowAllowedChildren, type RowErrorSpec, type RowField, type SanitizeFormConfigOptions, type SanitizedFormConfig, type SchemaApplicationConfig, type SchemaDefinition, type SimplifiedArrayField, type StateLogicConfig, type SubmissionActionResult, type SubmissionConfig, type SubmissionOutcome, type SubmissionReply, type SubmitButtonOptions, type TemplateAddon, type TextAddon, type TextElementType, type TextField, type TextProps, type TokenContext, type ValidationError, type ValidationExecutionConfig, type ValidationMessage, type ValidationMessageResolver, type ValidationMessages, type ValidatorConfig, type ValueExclusionConfig, type ValueFieldComponent, type ValueType, type WebMcpStatus, type WebMcpToolOptions, type WithInputSignals, type WrapperConfig, type WrapperRegistration, type WrapperTypeDefinition, type WrappersBundle, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue, rowError };