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

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

@@ -1,12 +1,9 @@
-import { FormEvent, FormEventConstructor, FormSubmitEvent, NextPageEvent, PreviousPageEvent, FieldWithValidation, ArrayItemContext, BaseAddon, DynamicValue } from '@ng-forge/dynamic-forms';
-export { BUILT_IN_FIELDS, FieldWrapper, InferWrapperRegistry, WrapperRegistration, WrapperTypeDefinition, WrappersBundle, createWrappers, isWrappersBundle, wrapperProps } from '@ng-forge/dynamic-forms';
-import { FieldDef, StateLogicConfig, BaseCheckedField, FieldMeta, BaseValueField, FieldOption, ArrayAllowedChildren, NonFieldLogicConfig, LogicConfig, ResolvedError, DynamicText, ValidationMessages, AnyAddon, AddonActionHandler, WrapperFieldInputs, AddonActionContext } from '@ng-forge/dynamic-forms/internal';
-export { ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AddonActionHandler, AddonShapeValidator, AddonTypeDefinition, AddonTypeSchema, ArrayContext, ArrayFieldTree, CheckedFieldComponent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DfAddonSlot, DynamicTextPipe, EventBus, FIELD_ERROR_DISPLAY, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FieldAddonSupport, FieldAddonSupportEntry, FieldErrorDisplayClaim, FieldErrors, FieldErrorsOptions, FieldErrorsWrapperBase, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FormFieldStateMap, GROUP_CONTEXT, HttpResourceRequest, INITIALIZATION_TIMEOUT_MS, MapperFn, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, PresetCollaborators, ReadonlyFieldTree, ResolvedError, RootFormRegistryService, ValueFieldComponent, ValueHandlingMode, WrapperFieldInputs, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, containerFieldMapper, createResolvedErrorsSignal, dynamicTextToObservable, getArrayLength, groupFieldMapper, injectAddonTypeRegistry, injectFieldErrors, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isCheckedField, isEqual, isValueField, pageFieldMapper, provideFieldErrorDisplay, resolveDynamicValue, resolveNonFieldDisabled, resolveNonFieldHidden, resolveTokens, rowFieldMapper, runPresetAction, shouldShowErrors, textFieldMapper, toReadonlyFieldTree, withPreviousValue, writeToFieldValue } from '@ng-forge/dynamic-forms/internal';
-import * as i0 from '@angular/core';
-import { Signal, ElementRef, InjectionToken } from '@angular/core';
-import { FieldTree } from '@angular/forms/signals';
-export { CreateNgForgeActionFixtureOptions, CreateNgForgeFieldFixtureOptions, NgForgeActionFixture, NgForgeFieldFixture, createNgForgeActionFixture, createNgForgeFieldFixture, provideTestValidationMessages } from '@ng-forge/dynamic-forms/testing';
-
+import { ArrayItemContext, BUILT_IN_FIELDS, BaseAddon, DynamicValue, FieldWithValidation, FieldWrapper, FormEvent, FormEventConstructor, FormSubmitEvent, InferWrapperRegistry, NextPageEvent, PreviousPageEvent, WrapperRegistration, WrapperTypeDefinition, WrappersBundle, createWrappers, isWrappersBundle, wrapperProps } from "@ng-forge/dynamic-forms";
+import { ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AddonActionContext, AddonActionHandler, AddonActionHandler as AddonActionHandler$1, AddonShapeValidator, AddonTypeDefinition, AddonTypeSchema, AnyAddon, ArrayAllowedChildren, ArrayContext, ArrayFieldTree, BaseCheckedField, BaseValueField, CheckedFieldComponent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DfAddonSlot, DynamicText, DynamicTextPipe, EventBus, FIELD_ERROR_DISPLAY, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FieldAddonSupport, FieldAddonSupportEntry, FieldDef, FieldErrorDisplayClaim, FieldErrors, FieldErrorsOptions, FieldErrorsWrapperBase, FieldMeta, FieldOption, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FormFieldStateMap, GROUP_CONTEXT, HttpResourceRequest, INITIALIZATION_TIMEOUT_MS, LogicConfig, MapperFn, NonFieldLogicConfig, NonFieldLogicConfig as NonFieldLogicConfig$1, NonFieldLogicContext, NonFieldLogicType, PresetCollaborators, ReadonlyFieldTree, ResolvedError, ResolvedError as ResolvedError$1, RootFormRegistryService, StateLogicConfig, ValidationMessages, ValueFieldComponent, ValueHandlingMode, WrapperFieldInputs, WrapperFieldInputs as WrapperFieldInputs$1, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, containerFieldMapper, createResolvedErrorsSignal, dynamicTextToObservable, getArrayLength, groupFieldMapper, injectAddonTypeRegistry, injectFieldErrors, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isCheckedField, isEqual, isValueField, pageFieldMapper, provideFieldErrorDisplay, resolveDynamicValue, resolveNonFieldDisabled, resolveNonFieldHidden, resolveTokens, rowFieldMapper, runPresetAction, shouldShowErrors, textFieldMapper, toReadonlyFieldTree, withPreviousValue, writeToFieldValue } from "@ng-forge/dynamic-forms/internal";
+import * as i0 from "@angular/core";
+import { ElementRef, InjectionToken, Signal } from "@angular/core";
+import { FieldTree } from "@angular/forms/signals";
+import { CreateNgForgeActionFixtureOptions, CreateNgForgeFieldFixtureOptions, NgForgeActionFixture, NgForgeFieldFixture, createNgForgeActionFixture, createNgForgeFieldFixture, provideTestValidationMessages } from "@ng-forge/dynamic-forms/testing";
 /**
  * Event arguments that can contain static values or tokens to be resolved at runtime.
  * Tokens supported: $key, $index, $arrayKey, $template, formValue
@@ -14,38 +11,35 @@ export { CreateNgForgeActionFixtureOptions, CreateNgForgeFieldFixtureOptions, Ng
 type EventArgs = readonly (string | number | boolean | null | undefined)[];
 /** Base interface for button fields. */
 interface ButtonField<TProps, TEvent extends FormEvent> extends FieldDef<TProps> {
-    type: 'button';
-    event: FormEventConstructor<TEvent>;
-    /**
-     * Optional arguments to pass to the event constructor.
-     * Can contain special tokens that will be resolved at runtime:
-     * - $key: The current field key
-     * - $index: The array index (if inside an array field)
-     * - $arrayKey: The parent array field key (if inside an array field)
-     * - $template: The template for array item creation (for array add buttons)
-     * - formValue: Access to the current form value for indexing
-     */
-    eventArgs?: EventArgs;
-    /** Logic rules for dynamic disabled state (overrides form-level defaults) */
-    logic?: StateLogicConfig[];
-}
-
+  type: 'button';
+  event: FormEventConstructor<TEvent>;
+  /**
+   * Optional arguments to pass to the event constructor.
+   * Can contain special tokens that will be resolved at runtime:
+   * - $key: The current field key
+   * - $index: The array index (if inside an array field)
+   * - $arrayKey: The parent array field key (if inside an array field)
+   * - $template: The template for array item creation (for array add buttons)
+   * - formValue: Access to the current form value for indexing
+   */
+  eventArgs?: EventArgs;
+  /** Logic rules for dynamic disabled state (overrides form-level defaults) */
+  logic?: StateLogicConfig[];
+}
 interface CheckboxField<TProps, TNullable extends boolean = boolean> extends BaseCheckedField<TProps, FieldMeta, TNullable> {
-    type: 'checkbox';
+  type: 'checkbox';
 }
-
 /**
  * Base props for datepicker fields. Intentionally empty — adapter libraries
  * extend this with adapter-specific options (startView, appearance, hint, etc.).
  */
 type DatepickerProps = object;
 interface DatepickerField<TProps, TNullable extends boolean = boolean> extends BaseValueField<TProps, Date | string, FieldMeta, TNullable> {
-    type: 'datepicker';
-    minDate?: Date | string | null;
-    maxDate?: Date | string | null;
-    startAt?: Date | null;
+  type: 'datepicker';
+  minDate?: Date | string | null;
+  maxDate?: Date | string | null;
+  startAt?: Date | null;
 }
-
 /**
  * Autocomplete values for HTML input elements.
  * Based on the WHATWG HTML specification for autofill.
@@ -73,26 +67,25 @@ type EnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | '
 type Autocapitalize = 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
 /** Meta attributes specific to HTML input elements. */
 interface InputMeta extends FieldMeta {
-    /** Hint for form autofill behavior. */
-    autocomplete?: AutocompleteValue;
-    /** Hint for virtual keyboard type on mobile devices. */
-    inputmode?: InputMode;
-    /** Hint for the enter key label on virtual keyboards. */
-    enterkeyhint?: EnterKeyHint;
-    /** Whether to enable spellchecking for the input. */
-    spellcheck?: boolean;
-    /** Hint for autocapitalization behavior on virtual keyboards. */
-    autocapitalize?: Autocapitalize;
-    /** Pattern for client-side validation (regex). */
-    pattern?: string;
-    /** Size hint for the input element (character count). */
-    size?: number;
-    /** Maximum number of characters allowed. */
-    maxlength?: number;
-    /** Minimum number of characters required. */
-    minlength?: number;
-}
-
+  /** Hint for form autofill behavior. */
+  autocomplete?: AutocompleteValue;
+  /** Hint for virtual keyboard type on mobile devices. */
+  inputmode?: InputMode;
+  /** Hint for the enter key label on virtual keyboards. */
+  enterkeyhint?: EnterKeyHint;
+  /** Whether to enable spellchecking for the input. */
+  spellcheck?: boolean;
+  /** Hint for autocapitalization behavior on virtual keyboards. */
+  autocapitalize?: Autocapitalize;
+  /** Pattern for client-side validation (regex). */
+  pattern?: string;
+  /** Size hint for the input element (character count). */
+  size?: number;
+  /** Maximum number of characters allowed. */
+  maxlength?: number;
+  /** Minimum number of characters required. */
+  minlength?: number;
+}
 /**
  * All valid HTML input types per MDN specification.
  *
@@ -116,12 +109,12 @@ type InferInputValue<T extends HtmlInputType> = T extends 'number' ? number : st
  * Generic parameter allows extending InputType with additional HtmlInputType values.
  */
 interface InputProps<T extends HtmlInputType = InputType> {
-    /**
-     * The HTML input type. Determines the value type:
-     * - 'number': value will be number
-     * - All other types: value will be string
-     */
-    type?: T;
+  /**
+   * The HTML input type. Determines the value type:
+   * - 'number': value will be number
+   * - All other types: value will be string
+   */
+  type?: T;
 }
 /**
  * Input types that produce numeric values.
@@ -136,14 +129,14 @@ type StringInputType<T extends HtmlInputType = InputType> = Exclude<T, 'number'>
  * Props is REQUIRED and must include type: 'number'.
  */
 interface NumberInputField<TProps extends {
-    type?: string;
+  type?: string;
 } = InputProps, TNullable extends boolean = boolean> extends BaseValueField<TProps & {
-    type: 'number';
+  type: 'number';
 }, number, InputMeta, TNullable> {
-    type: 'input';
-    props: TProps & {
-        type: 'number';
-    };
+  type: 'input';
+  props: TProps & {
+    type: 'number';
+  };
 }
 /**
  * String input field with strict string value type.
@@ -151,14 +144,14 @@ interface NumberInputField<TProps extends {
  * Props type cannot be 'number'.
  */
 interface StringInputField<TProps extends {
-    type?: string;
+  type?: string;
 } = InputProps, TNullable extends boolean = boolean> extends BaseValueField<TProps & {
-    type?: Exclude<TProps['type'], 'number'>;
+  type?: Exclude<TProps['type'], 'number'>;
 }, string, InputMeta, TNullable> {
-    type: 'input';
-    props?: TProps & {
-        type?: Exclude<TProps['type'], 'number'>;
-    };
+  type: 'input';
+  props?: TProps & {
+    type?: Exclude<TProps['type'], 'number'>;
+  };
 }
 /**
  * Builds discriminated union where props.type determines value type.
@@ -166,47 +159,42 @@ interface StringInputField<TProps extends {
  * - If props.type is undefined/text/email/etc, only StringInputField matches (value: string)
  */
 type BuildInputFieldUnion<TProps extends {
-    type?: string;
+  type?: string;
 }, TNullable extends boolean = boolean> = NumberInputField<TProps, TNullable> | StringInputField<TProps, TNullable>;
 /**
  * Input field with automatic type-safe value inference.
  * TypeScript automatically infers the correct value type based on props.type.
  */
 type InputField<TProps extends {
-    type?: string;
+  type?: string;
 } = InputProps, TNullable extends boolean = boolean> = BuildInputFieldUnion<TProps, TNullable>;
-
 /**
  * Multi-checkbox field for selecting multiple values from a list of options.
  * The value is an array of selected option values.
  */
 interface MultiCheckboxField<TValue, TProps = object, TNullable extends boolean = boolean> extends BaseValueField<TProps, TValue[], FieldMeta, TNullable> {
-    type: 'multi-checkbox';
-    readonly options: readonly FieldOption<TValue>[];
+  type: 'multi-checkbox';
+  readonly options: readonly FieldOption<TValue>[];
 }
-
 interface RadioField<T, TProps, TNullable extends boolean = boolean> extends BaseValueField<TProps, T, FieldMeta, TNullable> {
-    type: 'radio';
-    readonly options: readonly FieldOption<T>[];
+  type: 'radio';
+  readonly options: readonly FieldOption<T>[];
 }
-
 /**
  * Base props for select fields. Intentionally empty — adapter libraries
  * extend this with adapter-specific options (styleClass, size, appearance, etc.).
  */
 type SelectProps = object;
 interface SelectField<T, TProps = SelectProps, TNullable extends boolean = boolean> extends BaseValueField<TProps, T, FieldMeta, TNullable> {
-    type: 'select';
-    readonly options: readonly FieldOption<T>[];
+  type: 'select';
+  readonly options: readonly FieldOption<T>[];
 }
-
 interface SliderField<TProps, TNullable extends boolean = boolean> extends BaseValueField<TProps, number, FieldMeta, TNullable> {
-    type: 'slider';
-    minValue?: number;
-    maxValue?: number;
-    step?: number;
+  type: 'slider';
+  minValue?: number;
+  maxValue?: number;
+  step?: number;
 }
-
 /**
  * Text wrapping behavior for textarea elements.
  *
@@ -215,51 +203,48 @@ interface SliderField<TProps, TNullable extends boolean = boolean> extends BaseV
 type TextareaWrap = 'hard' | 'soft' | 'off';
 /** Meta attributes specific to HTML textarea elements. */
 interface TextareaMeta extends FieldMeta {
-    /**
-     * How text should wrap when submitted.
-     * - 'hard': Line breaks are inserted to wrap text at cols width
-     * - 'soft': Text is wrapped for display but not in submitted value
-     * - 'off': No wrapping, horizontal scrolling if needed
-     */
-    wrap?: TextareaWrap;
-    /** Whether to enable spellchecking for the textarea. */
-    spellcheck?: boolean;
-    /** Hint for form autofill behavior. */
-    autocomplete?: AutocompleteValue;
-    /** Hint for autocapitalization behavior on virtual keyboards. */
-    autocapitalize?: Autocapitalize;
-    /** Hint for the enter key label on virtual keyboards. */
-    enterkeyhint?: EnterKeyHint;
-    /** Maximum number of characters allowed. */
-    maxlength?: number;
-    /** Minimum number of characters required. */
-    minlength?: number;
-}
-
+  /**
+   * How text should wrap when submitted.
+   * - 'hard': Line breaks are inserted to wrap text at cols width
+   * - 'soft': Text is wrapped for display but not in submitted value
+   * - 'off': No wrapping, horizontal scrolling if needed
+   */
+  wrap?: TextareaWrap;
+  /** Whether to enable spellchecking for the textarea. */
+  spellcheck?: boolean;
+  /** Hint for form autofill behavior. */
+  autocomplete?: AutocompleteValue;
+  /** Hint for autocapitalization behavior on virtual keyboards. */
+  autocapitalize?: Autocapitalize;
+  /** Hint for the enter key label on virtual keyboards. */
+  enterkeyhint?: EnterKeyHint;
+  /** Maximum number of characters allowed. */
+  maxlength?: number;
+  /** Minimum number of characters required. */
+  minlength?: number;
+}
 interface TextareaProps {
-    rows?: number;
-    cols?: number | undefined;
+  rows?: number;
+  cols?: number | undefined;
 }
 interface TextareaField<TProps = TextareaProps, TNullable extends boolean = boolean> extends BaseValueField<TProps, string, TextareaMeta, TNullable> {
-    type: 'textarea';
-    maxLength?: number | undefined;
+  type: 'textarea';
+  maxLength?: number | undefined;
 }
-
 interface ToggleField<TProps, TNullable extends boolean = boolean> extends BaseCheckedField<TProps, FieldMeta, TNullable> {
-    type: 'toggle';
+  type: 'toggle';
 }
-
 /**
  * Context for value field mapping, containing the injected context reference.
  * Used by specialized mappers to avoid duplicate injection.
  */
 interface ValueFieldContext {
-    /**
-     * Gets the field tree for a given key from the form context.
-     * This is reactive for array items - the form getter is evaluated each time,
-     * allowing the computed to re-run when the root form structure updates.
-     */
-    getFieldTree: (fieldKey: string) => FieldTree<unknown> | undefined;
+  /**
+   * Gets the field tree for a given key from the form context.
+   * This is reactive for array items - the form getter is evaluated each time,
+   * allowing the computed to re-run when the root form structure updates.
+   */
+  getFieldTree: (fieldKey: string) => FieldTree<unknown> | undefined;
 }
 /**
  * Creates a value field context from the injected FIELD_SIGNAL_CONTEXT.
@@ -267,7 +252,7 @@ interface ValueFieldContext {
  *
  * @returns The value field context with reactive field tree accessor
  */
-declare function resolveValueFieldContext(): ValueFieldContext;
+export declare function resolveValueFieldContext(): ValueFieldContext;
 /**
  * Builds the base inputs for a value field.
  * This is a helper function used by valueFieldMapper and specialized mappers.
@@ -277,31 +262,28 @@ declare function resolveValueFieldContext(): ValueFieldContext;
  * @param defaultProps Default props from the form configuration (may be undefined if not configured)
  * @returns Record of input names to values
  */
-declare function buildValueFieldInputs<TProps, TValue = unknown>(fieldDef: BaseValueField<TProps, TValue, FieldMeta, boolean>, ctx: ValueFieldContext, defaultProps?: Record<string, unknown>): Record<string, unknown>;
+export declare function buildValueFieldInputs<TProps, TValue = unknown>(fieldDef: BaseValueField<TProps, TValue, FieldMeta, boolean>, ctx: ValueFieldContext, defaultProps?: Record<string, unknown>): Record<string, unknown>;
 /**
  * Maps a value field definition to component inputs.
  *
  * @param fieldDef The value field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
-declare function valueFieldMapper<TProps = unknown, TValue = unknown>(fieldDef: BaseValueField<TProps, TValue, FieldMeta, boolean>): Signal<Record<string, unknown>>;
-
+export declare function valueFieldMapper<TProps = unknown, TValue = unknown>(fieldDef: BaseValueField<TProps, TValue, FieldMeta, boolean>): Signal<Record<string, unknown>>;
 /**
  * Maps a checkbox/toggle field definition to component inputs.
  *
  * @param fieldDef The checkbox field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
-declare function checkboxFieldMapper(fieldDef: BaseCheckedField<unknown, FieldMeta, boolean>): Signal<Record<string, unknown>>;
-
+export declare function checkboxFieldMapper(fieldDef: BaseCheckedField<unknown, FieldMeta, boolean>): Signal<Record<string, unknown>>;
 /**
  * Maps a datepicker field to component inputs.
  *
  * @param fieldDef The datepicker field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
-declare function datepickerFieldMapper<TProps>(fieldDef: DatepickerField<TProps>): Signal<Record<string, unknown>>;
-
+export declare function datepickerFieldMapper<TProps>(fieldDef: DatepickerField<TProps>): Signal<Record<string, unknown>>;
 /** Field types that have an options property. */
 type FieldWithOptions<T = unknown, TProps = unknown> = SelectField<T, TProps> | RadioField<T, TProps> | MultiCheckboxField<T, TProps>;
 /**
@@ -310,51 +292,49 @@ type FieldWithOptions<T = unknown, TProps = unknown> = SelectField<T, TProps> |
  * @param fieldDef The field definition with options
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
-declare function optionsFieldMapper<T, TProps>(fieldDef: FieldWithOptions<T, TProps>): Signal<Record<string, unknown>>;
-
+export declare function optionsFieldMapper<T, TProps>(fieldDef: FieldWithOptions<T, TProps>): Signal<Record<string, unknown>>;
 /**
  * Maps a button field to component inputs.
  *
  * @param fieldDef The button field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
-declare function buttonFieldMapper<TProps, TEvent extends FormEvent>(fieldDef: ButtonField<TProps, TEvent>): Signal<Record<string, unknown>>;
-
+export declare function buttonFieldMapper<TProps, TEvent extends FormEvent>(fieldDef: ButtonField<TProps, TEvent>): Signal<Record<string, unknown>>;
 /**
  * Context for array button mapping, containing resolved array information.
  * Used by array button mappers to build event context.
  */
 interface ArrayButtonContext {
-    /** The target array key (from explicit arrayKey or ARRAY_CONTEXT) */
-    targetArrayKey: string | undefined;
-    /** Computed signal that returns the current array index (-1 if not inside array) */
-    indexSignal: Signal<number>;
-    /**
-     * Current form value for token resolution. Implemented as a lazy getter so it
-     * is read at event-dispatch time, not when the mapper builds its context —
-     * reading it eagerly inside the mapper's computed would resnapshot a stale
-     * value and subscribe every array button to the whole form entity per
-     * keystroke. Keep it a getter on any reimplementation.
-     */
-    formValue: Record<string, unknown>;
-    /** Whether this button is inside an array context */
-    isInsideArray: boolean;
+  /** The target array key (from explicit arrayKey or ARRAY_CONTEXT) */
+  targetArrayKey: string | undefined;
+  /** Computed signal that returns the current array index (-1 if not inside array) */
+  indexSignal: Signal<number>;
+  /**
+   * Current form value for token resolution. Implemented as a lazy getter so it
+   * is read at event-dispatch time, not when the mapper builds its context —
+   * reading it eagerly inside the mapper's computed would resnapshot a stale
+   * value and subscribe every array button to the whole form entity per
+   * keystroke. Keep it a getter on any reimplementation.
+   */
+  formValue: Record<string, unknown>;
+  /** Whether this button is inside an array context */
+  isInsideArray: boolean;
 }
 /** Event context passed to button components for array operations. */
 interface ArrayButtonEventContext {
-    /** The button field key */
-    key: string;
-    /** The current array index (-1 if outside array) */
-    index: number;
-    /** The target array key */
-    arrayKey: string;
-    /** Form value for token resolution — a lazy getter, resolved at dispatch time. See {@link ArrayButtonContext.formValue}. */
-    formValue: Record<string, unknown>;
-    /**
-     * Optional template for add operations.
-     * Can be a single field (primitive item) or array of fields (object item).
-     */
-    template?: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
+  /** The button field key */
+  key: string;
+  /** The current array index (-1 if outside array) */
+  index: number;
+  /** The target array key */
+  arrayKey: string;
+  /** Form value for token resolution — a lazy getter, resolved at dispatch time. See {@link ArrayButtonContext.formValue}. */
+  formValue: Record<string, unknown>;
+  /**
+   * Optional template for add operations.
+   * Can be a single field (primitive item) or array of fields (object item).
+   */
+  template?: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
 }
 /**
  * Resolves array button context for button mappers.
@@ -364,7 +344,7 @@ interface ArrayButtonEventContext {
  * @param explicitArrayKey Optional explicit arrayKey from field definition
  * @returns The array button context with reactive index signal
  */
-declare function resolveArrayButtonContext(fieldKey: string, buttonType: string, explicitArrayKey?: string): ArrayButtonContext;
+export declare function resolveArrayButtonContext(fieldKey: string, buttonType: string, explicitArrayKey?: string): ArrayButtonContext;
 /**
  * Builds the event context passed to the button component.
  *
@@ -373,7 +353,7 @@ declare function resolveArrayButtonContext(fieldKey: string, buttonType: string,
  * @param template Optional template for add operations (single field or array of fields)
  * @returns The event context for the button component
  */
-declare function buildArrayButtonEventContext(fieldKey: string, ctx: ArrayButtonContext, template?: ArrayAllowedChildren | readonly ArrayAllowedChildren[]): ArrayButtonEventContext;
+export declare function buildArrayButtonEventContext(fieldKey: string, ctx: ArrayButtonContext, template?: ArrayAllowedChildren | readonly ArrayAllowedChildren[]): ArrayButtonEventContext;
 /**
  * Event argument type - supports static values and tokens.
  * Tokens: $key, $index, $arrayKey, $template, formValue
@@ -386,25 +366,24 @@ type EventArg = string | number | boolean | null | undefined;
  * @param defaultEventArgs The default eventArgs to use if not specified
  * @returns The resolved eventArgs array
  */
-declare function resolveArrayButtonEventArgs(fieldEventArgs: readonly EventArg[] | undefined, defaultEventArgs?: readonly EventArg[]): readonly EventArg[];
-
+export declare function resolveArrayButtonEventArgs(fieldEventArgs: readonly EventArg[] | undefined, defaultEventArgs?: readonly EventArg[]): readonly EventArg[];
 /**
  * Field definition with optional hidden/disabled and logic properties.
  * This is the minimal interface needed by applyNonFieldLogic.
  */
 interface FieldDefWithLogic {
-    key?: string;
-    hidden?: boolean;
-    disabled?: boolean;
-    logic?: NonFieldLogicConfig[] | LogicConfig[];
+  key?: string;
+  hidden?: boolean;
+  disabled?: boolean;
+  logic?: NonFieldLogicConfig$1[] | LogicConfig[];
 }
 /**
  * Result of applying non-field logic to a field.
  * Only includes properties that have values to apply.
  */
 interface NonFieldLogicResult {
-    hidden?: boolean;
-    disabled?: boolean;
+  hidden?: boolean;
+  disabled?: boolean;
 }
 /**
  * Injects everything a non-form-bound button mapper needs to evaluate hidden/disabled logic,
@@ -412,113 +391,110 @@ interface NonFieldLogicResult {
  * generic `{ type: 'button', logic: [...] }` evaluates its conditions with `externalData` and
  * custom functions in scope, matching the built-in button field types.
  */
-declare function injectNonFieldLogicResolver(fieldDef: FieldDefWithLogic): () => NonFieldLogicResult;
-
+export declare function injectNonFieldLogicResolver(fieldDef: FieldDefWithLogic): () => NonFieldLogicResult;
 /**
  * Base interface for array add button fields (append, prepend, insert).
  * Template is required to define the structure for new items.
  */
 interface BaseArrayAddButtonField<TProps = unknown> {
-    key: string;
-    type: string;
-    label?: string;
-    disabled?: boolean;
-    hidden?: boolean;
-    className?: string;
-    props?: TProps;
-    /** Target array key (required when outside array, optional inside) */
-    arrayKey?: string;
-    /**
-     * Template defining the field structure for new items. REQUIRED.
-     * - Single field (ArrayAllowedChildren): Creates a primitive item (field's value is extracted directly)
-     * - Array of fields (ArrayAllowedChildren[]): Creates an object item (fields merged into object)
-     */
-    template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
-    /** Optional custom eventArgs */
-    eventArgs?: readonly EventArg[];
-    /** Logic rules for dynamic hidden/disabled state (only hidden and disabled are supported) */
-    logic?: NonFieldLogicConfig[];
+  key: string;
+  type: string;
+  label?: string;
+  disabled?: boolean;
+  hidden?: boolean;
+  className?: string;
+  props?: TProps;
+  /** Target array key (required when outside array, optional inside) */
+  arrayKey?: string;
+  /**
+   * Template defining the field structure for new items. REQUIRED.
+   * - Single field (ArrayAllowedChildren): Creates a primitive item (field's value is extracted directly)
+   * - Array of fields (ArrayAllowedChildren[]): Creates an object item (fields merged into object)
+   */
+  template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
+  /** Optional custom eventArgs */
+  eventArgs?: readonly EventArg[];
+  /** Logic rules for dynamic hidden/disabled state (only hidden and disabled are supported) */
+  logic?: NonFieldLogicConfig$1[];
 }
 /**
  * Base interface for array remove button fields (remove, pop, shift).
  * No template needed - removes existing items.
  */
 interface BaseArrayRemoveButtonField<TProps = unknown> {
-    key: string;
-    type: string;
-    label?: string;
-    disabled?: boolean;
-    hidden?: boolean;
-    className?: string;
-    props?: TProps;
-    /** Target array key (required when outside array, optional inside) */
-    arrayKey?: string;
-    /** Optional custom eventArgs */
-    eventArgs?: readonly EventArg[];
-    /** Logic rules for dynamic hidden/disabled state (only hidden and disabled are supported) */
-    logic?: NonFieldLogicConfig[];
+  key: string;
+  type: string;
+  label?: string;
+  disabled?: boolean;
+  hidden?: boolean;
+  className?: string;
+  props?: TProps;
+  /** Target array key (required when outside array, optional inside) */
+  arrayKey?: string;
+  /** Optional custom eventArgs */
+  eventArgs?: readonly EventArg[];
+  /** Logic rules for dynamic hidden/disabled state (only hidden and disabled are supported) */
+  logic?: NonFieldLogicConfig$1[];
 }
 /**
  * Interface for insert array item button fields.
  * Extends add button with required index.
  */
 interface BaseInsertArrayItemButtonField<TProps = unknown> extends BaseArrayAddButtonField<TProps> {
-    /** The index at which to insert the new item */
-    index: number;
+  /** The index at which to insert the new item */
+  index: number;
 }
 /**
  * Mapper for add array item button — appends new item to end of array.
  * Template is REQUIRED to define the field structure for new items.
  */
-declare function addArrayItemButtonMapper<TProps>(fieldDef: BaseArrayAddButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function addArrayItemButtonMapper<TProps>(fieldDef: BaseArrayAddButtonField<TProps>): Signal<Record<string, unknown>>;
 /**
  * Mapper for prepend array item button — inserts new item at beginning of array.
  * Template is REQUIRED to define the field structure for new items.
  */
-declare function prependArrayItemButtonMapper<TProps>(fieldDef: BaseArrayAddButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function prependArrayItemButtonMapper<TProps>(fieldDef: BaseArrayAddButtonField<TProps>): Signal<Record<string, unknown>>;
 /**
  * Mapper for insert array item button — inserts new item at specific index.
  * Template and index are REQUIRED.
  */
-declare function insertArrayItemButtonMapper<TProps>(fieldDef: BaseInsertArrayItemButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function insertArrayItemButtonMapper<TProps>(fieldDef: BaseInsertArrayItemButtonField<TProps>): Signal<Record<string, unknown>>;
 /**
  * Mapper for remove array item button.
  * Inside array: RemoveAtIndexEvent. Outside array: PopArrayItemEvent.
  */
-declare function removeArrayItemButtonMapper<TProps>(fieldDef: BaseArrayRemoveButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function removeArrayItemButtonMapper<TProps>(fieldDef: BaseArrayRemoveButtonField<TProps>): Signal<Record<string, unknown>>;
 /** Mapper for pop array item button — removes the last item from array. */
-declare function popArrayItemButtonMapper<TProps>(fieldDef: BaseArrayRemoveButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function popArrayItemButtonMapper<TProps>(fieldDef: BaseArrayRemoveButtonField<TProps>): Signal<Record<string, unknown>>;
 /** Mapper for shift array item button — removes the first item from array. */
-declare function shiftArrayItemButtonMapper<TProps>(fieldDef: BaseArrayRemoveButtonField<TProps>): Signal<Record<string, unknown>>;
-
+export declare function shiftArrayItemButtonMapper<TProps>(fieldDef: BaseArrayRemoveButtonField<TProps>): Signal<Record<string, unknown>>;
 /** Base interface for navigation button fields (submit, next, previous). */
 type BaseNavigationButtonField<TProps = unknown> = ButtonField<TProps, FormSubmitEvent | NextPageEvent | PreviousPageEvent> & {
-    type: string;
-    /** Logic rules for dynamic disabled state */
-    logic?: FieldWithValidation['logic'];
+  type: string;
+  /** Logic rules for dynamic disabled state */
+  logic?: FieldWithValidation['logic'];
 };
 /**
  * Mapper for submit button — configures native form submission via type="submit".
  * Triggers native form submission rather than dispatching events directly.
  */
-declare function submitButtonFieldMapper<TProps>(fieldDef: BaseNavigationButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function submitButtonFieldMapper<TProps>(fieldDef: BaseNavigationButtonField<TProps>): Signal<Record<string, unknown>>;
 /** Mapper for next page button — preconfigures NextPageEvent. */
-declare function nextButtonFieldMapper<TProps>(fieldDef: BaseNavigationButtonField<TProps>): Signal<Record<string, unknown>>;
+export declare function nextButtonFieldMapper<TProps>(fieldDef: BaseNavigationButtonField<TProps>): Signal<Record<string, unknown>>;
 /** Mapper for previous page button — preconfigures PreviousPageEvent. */
-declare function previousButtonFieldMapper<TProps>(fieldDef: BaseNavigationButtonField<TProps>): Signal<Record<string, unknown>>;
-
+export declare function previousButtonFieldMapper<TProps>(fieldDef: BaseNavigationButtonField<TProps>): Signal<Record<string, unknown>>;
 /** Configuration options for setupMetaTracking. */
 interface MetaTrackingOptions {
-    /**
-     * CSS selector for target elements within the host.
-     * If not provided, meta attributes are applied directly to the host element.
-     */
-    selector?: string;
-    /**
-     * Additional signals to track that should trigger re-application of meta.
-     * Useful for components where DOM elements are dynamically created (e.g., radio options).
-     */
-    dependents?: Signal<unknown>[];
+  /**
+   * CSS selector for target elements within the host.
+   * If not provided, meta attributes are applied directly to the host element.
+   */
+  selector?: string;
+  /**
+   * Additional signals to track that should trigger re-application of meta.
+   * Useful for components where DOM elements are dynamically created (e.g., radio options).
+   */
+  dependents?: Signal<unknown>[];
 }
 /**
  * Sets up automatic meta attribute tracking and application for wrapped components.
@@ -527,8 +503,7 @@ interface MetaTrackingOptions {
  * @param meta - Signal containing meta attributes to apply
  * @param options - Configuration options
  */
-declare function setupMetaTracking(elementRef: ElementRef<HTMLElement>, meta: Signal<FieldMeta | undefined>, options?: MetaTrackingOptions): void;
-
+export declare function setupMetaTracking(elementRef: ElementRef<HTMLElement>, meta: Signal<FieldMeta | undefined>, options?: MetaTrackingOptions): void;
 /**
  * Creates a signal that computes the aria-describedby value based on errors and hint state.
  * Errors take precedence over hints - when errors are displayed, the hint is hidden.
@@ -540,23 +515,32 @@ declare function setupMetaTracking(elementRef: ElementRef<HTMLElement>, meta: Si
  * @param hasHint Function that returns true if a hint is configured
  * @returns Signal containing the aria-describedby value or null
  */
-declare function createAriaDescribedBySignal(errorsToDisplay: Signal<ResolvedError[]>, errorId: Signal<string>, hintId: Signal<string>, hasHint: () => boolean): Signal<string | null>;
-
+export declare function createAriaDescribedBySignal(errorsToDisplay: Signal<ResolvedError$1[]>, errorId: Signal<string>, hintId: Signal<string>, hasHint: () => boolean): Signal<string | null>;
 /**
  * Base directive composed into every ng-forge component via `hostDirectives`.
  * Owns the universal identity inputs (`key`, `className`) and the host
  * bindings that every field shape — value-bearing, action, future container —
  * shares: `[id]`, `[attr.data-testid]`, `[class]`.
  */
-declare class NgForgeFieldShell {
-    readonly key: i0.InputSignal<string>;
-    readonly className: i0.InputSignal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeFieldShell, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeFieldShell, never, never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NgForgeFieldShell {
+  readonly key: import("@angular/core").InputSignal<string>;
+  readonly className: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeFieldShell, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeFieldShell, never, never, {
+    "key": {
+      "alias": "key";
+      "required": true;
+      "isSignal": true;
+    };
+    "className": {
+      "alias": "className";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /** Input names forwarded onto `NgForgeFieldShell` via `hostDirectives`. */
-declare const NG_FORGE_FIELD_SHELL_INPUTS: readonly ["key", "className"];
-
+export declare const NG_FORGE_FIELD_SHELL_INPUTS: readonly ["key", "className"];
 /**
  * Value-bearing add-on directive — composed alongside `NgForgeFieldShell` via
  * the `NG_FORGE_FIELD` preset. Owns the value/validation/aria plumbing every
@@ -575,37 +559,73 @@ declare const NG_FORGE_FIELD_SHELL_INPUTS: readonly ["key", "className"];
  * Selectorless — usage is exclusively via `hostDirectives`. Prefer the
  * `NG_FORGE_FIELD` preset over composing this directive manually.
  */
-declare class NgForgeField {
-    private readonly shell;
-    /** Shell-owned key, re-exported as plain `Signal<string>` so it doesn't get flagged by the host-directive input-lockstep assertion. */
-    readonly key: Signal<string>;
-    /** Shell-owned className, re-exported as plain `Signal<string>` for the same reason. */
-    readonly className: Signal<string>;
-    readonly field: i0.InputSignal<FieldTree<unknown>>;
-    readonly label: i0.InputSignal<DynamicText | undefined>;
-    readonly placeholder: i0.InputSignal<DynamicText | undefined>;
-    readonly tabIndex: i0.InputSignal<number | undefined>;
-    readonly props: i0.InputSignal<unknown>;
-    readonly meta: i0.InputSignal<FieldMeta | undefined>;
-    readonly validationMessages: i0.InputSignal<ValidationMessages | undefined>;
-    private readonly defaultValidationMessages;
-    readonly errors: Signal<ResolvedError[]>;
-    readonly showErrors: Signal<boolean>;
-    /** An ancestor wrapper's claim to render errors — see `FIELD_ERROR_DISPLAY`. */
-    private readonly errorDisplayClaim;
-    readonly errorsToDisplay: Signal<ResolvedError[]>;
-    readonly errorId: Signal<string>;
-    readonly hintId: Signal<string>;
-    readonly ariaInvalid: Signal<boolean>;
-    readonly ariaRequired: Signal<true | null>;
-    readonly ariaDescribedBy: Signal<string | null>;
-    private readonly _claimed;
-    /** @internal Marker directives + ambient sub-components call this on construction. */
-    markClaimed(): void;
-    private readonly logger;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeField, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeField, never, never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NgForgeField {
+  private readonly shell;
+  /** Shell-owned key, re-exported as plain `Signal<string>` so it doesn't get flagged by the host-directive input-lockstep assertion. */
+  readonly key: Signal<string>;
+  /** Shell-owned className, re-exported as plain `Signal<string>` for the same reason. */
+  readonly className: Signal<string>;
+  readonly field: import("@angular/core").InputSignal<FieldTree<unknown>>;
+  readonly label: import("@angular/core").InputSignal<DynamicText | undefined>;
+  readonly placeholder: import("@angular/core").InputSignal<DynamicText | undefined>;
+  readonly tabIndex: import("@angular/core").InputSignal<number | undefined>;
+  readonly props: import("@angular/core").InputSignal<unknown>;
+  readonly meta: import("@angular/core").InputSignal<FieldMeta | undefined>;
+  readonly validationMessages: import("@angular/core").InputSignal<ValidationMessages | undefined>;
+  private readonly defaultValidationMessages;
+  readonly errors: Signal<ResolvedError$1[]>;
+  readonly showErrors: Signal<boolean>;
+  /** An ancestor wrapper's claim to render errors — see `FIELD_ERROR_DISPLAY`. */
+  private readonly errorDisplayClaim;
+  readonly errorsToDisplay: Signal<ResolvedError$1[]>;
+  readonly errorId: Signal<string>;
+  readonly hintId: Signal<string>;
+  readonly ariaInvalid: Signal<boolean>;
+  readonly ariaRequired: Signal<true | null>;
+  readonly ariaDescribedBy: Signal<string | null>;
+  private readonly _claimed;
+  /** @internal Marker directives + ambient sub-components call this on construction. */
+  markClaimed(): void;
+  private readonly logger;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeField, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeField, never, never, {
+    "field": {
+      "alias": "field";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "tabIndex": {
+      "alias": "tabIndex";
+      "required": false;
+      "isSignal": true;
+    };
+    "props": {
+      "alias": "props";
+      "required": false;
+      "isSignal": true;
+    };
+    "meta": {
+      "alias": "meta";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationMessages": {
+      "alias": "validationMessages";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /**
  * Inputs forwarded onto `NgForgeField` via `hostDirectives`. Excludes
@@ -613,7 +633,7 @@ declare class NgForgeField {
  * `NG_FORGE_FIELD_SHELL_INPUTS`). Most consumers shouldn't reference this
  * directly — use the `NG_FORGE_FIELD` preset.
  */
-declare const NG_FORGE_VALUE_FIELD_INPUTS: readonly ["field", "label", "placeholder", "tabIndex", "props", "meta", "validationMessages"];
+export declare const NG_FORGE_VALUE_FIELD_INPUTS: readonly ["field", "label", "placeholder", "tabIndex", "props", "meta", "validationMessages"];
 /**
  * `NgForgeField` typed for a specific value type. The directive itself stores
  * `field` as `Signal<FieldTree<unknown>>` because Angular's `hostDirectives`
@@ -621,7 +641,7 @@ declare const NG_FORGE_VALUE_FIELD_INPUTS: readonly ["field", "label", "placehol
  * inject site so consumers don't have to declare a separate cast computed.
  */
 type TypedNgForgeField<T> = Omit<NgForgeField, 'field'> & {
-    readonly field: Signal<FieldTree<T>>;
+  readonly field: Signal<FieldTree<T>>;
 };
 /**
  * Typed wrapper around `inject(NgForgeField)`. The generic narrows the
@@ -629,8 +649,7 @@ type TypedNgForgeField<T> = Omit<NgForgeField, 'field'> & {
  * type. The cast is unchecked — the runtime contract is that mappers only
  * forward a `field` whose value type matches the field-type definition.
  */
-declare function injectNgForgeField<T = unknown>(): TypedNgForgeField<T>;
-
+export declare function injectNgForgeField<T = unknown>(): TypedNgForgeField<T>;
 /**
  * Action add-on directive — composed alongside `NgForgeFieldShell` via the
  * `NG_FORGE_ACTION` preset. Owns the inputs + dispatch logic every button /
@@ -638,30 +657,71 @@ declare function injectNgForgeField<T = unknown>(): TypedNgForgeField<T>;
  * `[attr.hidden]` / `[attr.aria-disabled]` host bindings driven by its own
  * inputs (no field tree).
  */
-declare class NgForgeAction<TEvent extends FormEvent = FormEvent> {
-    private readonly shell;
-    readonly key: Signal<string>;
-    readonly className: Signal<string>;
-    readonly label: i0.InputSignal<DynamicText>;
-    readonly disabled: i0.InputSignal<boolean>;
-    readonly hidden: i0.InputSignal<boolean>;
-    readonly tabIndex: i0.InputSignal<number | undefined>;
-    readonly event: i0.InputSignal<FormEventConstructor<TEvent> | undefined>;
-    readonly eventArgs: i0.InputSignal<EventArgs | undefined>;
-    readonly eventContext: i0.InputSignal<ArrayItemContext | undefined>;
-    readonly props: i0.InputSignal<unknown>;
-    private readonly eventBus;
-    private readonly arrayContext;
-    /**
-     * Dispatch the configured event through the EventBus. Resolves `eventArgs`
-     * tokens (`$key`, `$index`, `$arrayKey`, `formValue`, …) against the
-     * ambient array context if present, falling back to a static `eventContext`
-     * input or the field's own `key` otherwise. No-op when `event` is unset
-     * (e.g. submit buttons handled by the native form lifecycle).
-     */
-    dispatch(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAction<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAction<any>, never, never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "event": { "alias": "event"; "required": false; "isSignal": true; }; "eventArgs": { "alias": "eventArgs"; "required": false; "isSignal": true; }; "eventContext": { "alias": "eventContext"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NgForgeAction<TEvent extends FormEvent = FormEvent> {
+  private readonly shell;
+  readonly key: Signal<string>;
+  readonly className: Signal<string>;
+  readonly label: import("@angular/core").InputSignal<DynamicText>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly hidden: import("@angular/core").InputSignal<boolean>;
+  readonly tabIndex: import("@angular/core").InputSignal<number | undefined>;
+  readonly event: import("@angular/core").InputSignal<FormEventConstructor<TEvent> | undefined>;
+  readonly eventArgs: import("@angular/core").InputSignal<EventArgs | undefined>;
+  readonly eventContext: import("@angular/core").InputSignal<ArrayItemContext | undefined>;
+  readonly props: import("@angular/core").InputSignal<unknown>;
+  private readonly eventBus;
+  private readonly arrayContext;
+  /**
+   * Dispatch the configured event through the EventBus. Resolves `eventArgs`
+   * tokens (`$key`, `$index`, `$arrayKey`, `formValue`, …) against the
+   * ambient array context if present, falling back to a static `eventContext`
+   * input or the field's own `key` otherwise. No-op when `event` is unset
+   * (e.g. submit buttons handled by the native form lifecycle).
+   */
+  dispatch(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAction<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAction<any>, never, never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "tabIndex": {
+      "alias": "tabIndex";
+      "required": false;
+      "isSignal": true;
+    };
+    "event": {
+      "alias": "event";
+      "required": false;
+      "isSignal": true;
+    };
+    "eventArgs": {
+      "alias": "eventArgs";
+      "required": false;
+      "isSignal": true;
+    };
+    "eventContext": {
+      "alias": "eventContext";
+      "required": false;
+      "isSignal": true;
+    };
+    "props": {
+      "alias": "props";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /**
  * Inputs forwarded onto `NgForgeAction` via `hostDirectives`. Excludes
@@ -669,51 +729,56 @@ declare class NgForgeAction<TEvent extends FormEvent = FormEvent> {
  * `NG_FORGE_FIELD_SHELL_INPUTS`). Most consumers shouldn't reference this
  * directly — use the `NG_FORGE_ACTION` preset.
  */
-declare const NG_FORGE_ACTION_INPUTS: readonly ["label", "disabled", "hidden", "tabIndex", "event", "eventArgs", "eventContext", "props"];
+export declare const NG_FORGE_ACTION_INPUTS: readonly ["label", "disabled", "hidden", "tabIndex", "event", "eventArgs", "eventContext", "props"];
 /**
  * Typed wrapper around `inject(NgForgeAction)`. The generic narrows the
  * `event` input to a specific FormEvent subclass.
  */
-declare function injectNgForgeAction<TEvent extends FormEvent = FormEvent>(): NgForgeAction<TEvent>;
-
+export declare function injectNgForgeAction<TEvent extends FormEvent = FormEvent>(): NgForgeAction<TEvent>;
 /**
  * Universal addon-array plumbing: signal-cached `hidden` resolution and
  * slot bucketing. Used internally by the `NgForgeAddons` host wrapper —
  * consumers should compose `NgForgeAddons` directly and inject the
  * directive instance via `injectNgForgeAddons<TAddon>()`.
  */
-declare class NgForgeAddonsBase {
-    /** Capture the host's injector so `toSignal` (inside `resolveDynamicValue`) ties to the host's `DestroyRef`. */
-    private readonly hostInjector;
-    /** Addon array mapped from `FieldDef.addons` by `buildBaseInputs`. */
-    readonly addons: i0.InputSignal<readonly AnyAddon[] | undefined>;
-    /**
-     * Per-addon `hidden` signal cache. Built via `explicitEffect` rather
-     * than `computed` because `toSignal` (inside `resolveDynamicValue` for
-     * Observable inputs) is disallowed in reactive contexts (NG0602).
-     */
-    private readonly _hiddenSignalCache;
-    readonly hiddenSignalCache: Signal<ReadonlyMap<AnyAddon, Signal<boolean>>>;
-    readonly visibleAddons: Signal<ReadonlyArray<AnyAddon>>;
-    readonly hasAddons: Signal<boolean>;
-    readonly prefixAddons: Signal<ReadonlyArray<AnyAddon>>;
-    readonly suffixAddons: Signal<ReadonlyArray<AnyAddon>>;
-    /**
-     * Visible addons grouped by their `slot` string. Convenience view for
-     * adapters with non-universal slots (e.g., Ionic `start` / `end`).
-     */
-    readonly addonsBySlot: Signal<ReadonlyMap<string, ReadonlyArray<AnyAddon>>>;
-    /** Secondary index keyed by `hidden` value identity. Catches the common case
-     *  where a FormConfig re-emit produces structurally-different-but-content-
-     *  identical addon objects — without this, every re-emit would spawn a new
-     *  `toSignal` subscription for each addon's hidden axis. */
-    private readonly _hiddenByValue;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddonsBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddonsBase, never, never, { "addons": { "alias": "addons"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NgForgeAddonsBase {
+  /** Capture the host's injector so `toSignal` (inside `resolveDynamicValue`) ties to the host's `DestroyRef`. */
+  private readonly hostInjector;
+  /** Addon array mapped from `FieldDef.addons` by `buildBaseInputs`. */
+  readonly addons: import("@angular/core").InputSignal<readonly AnyAddon[] | undefined>;
+  /**
+   * Per-addon `hidden` signal cache. Built via `explicitEffect` rather
+   * than `computed` because `toSignal` (inside `resolveDynamicValue` for
+   * Observable inputs) is disallowed in reactive contexts (NG0602).
+   */
+  private readonly _hiddenSignalCache;
+  readonly hiddenSignalCache: Signal<ReadonlyMap<AnyAddon, Signal<boolean>>>;
+  readonly visibleAddons: Signal<ReadonlyArray<AnyAddon>>;
+  readonly hasAddons: Signal<boolean>;
+  readonly prefixAddons: Signal<ReadonlyArray<AnyAddon>>;
+  readonly suffixAddons: Signal<ReadonlyArray<AnyAddon>>;
+  /**
+   * Visible addons grouped by their `slot` string. Convenience view for
+   * adapters with non-universal slots (e.g., Ionic `start` / `end`).
+   */
+  readonly addonsBySlot: Signal<ReadonlyMap<string, ReadonlyArray<AnyAddon>>>;
+  /** Secondary index keyed by `hidden` value identity. Catches the common case
+   *  where a FormConfig re-emit produces structurally-different-but-content-
+   *  identical addon objects — without this, every re-emit would spawn a new
+   *  `toSignal` subscription for each addon's hidden axis. */
+  private readonly _hiddenByValue;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddonsBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddonsBase, never, never, {
+    "addons": {
+      "alias": "addons";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /** Forwarded onto `NgForgeAddonsBase` via the `NgForgeAddons` wrapper. */
-declare const NG_FORGE_ADDONS_INPUTS: readonly ["addons"];
+export declare const NG_FORGE_ADDONS_INPUTS: readonly ["addons"];
 /**
  * Host wrapper for `NgForgeAddonsBase`. Consumers compose this directly:
  *
@@ -735,35 +800,40 @@ declare const NG_FORGE_ADDONS_INPUTS: readonly ["addons"];
  * The wrapper exists so `hostDirectives: [NgForgeAddons]` resolves
  * cross-package — same constraint that drives `NgForgeFieldHost`.
  */
-declare class NgForgeAddons {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddons, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddons, never, never, {}, {}, never, never, true, [{ directive: typeof NgForgeAddonsBase; inputs: { "addons": "addons"; }; outputs: {}; }]>;
+export declare class NgForgeAddons {
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddons, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddons, never, never, {}, {}, never, never, true, [{
+    directive: typeof NgForgeAddonsBase;
+    inputs: {
+      "addons": "addons";
+    };
+    outputs: {};
+  }]>;
 }
 /** Narrowed view of `NgForgeAddonsBase` returned by `injectNgForgeAddons<TAddon>()`. */
 type TypedNgForgeAddons<TAddon extends AnyAddon = AnyAddon> = Omit<NgForgeAddonsBase, 'addons' | 'visibleAddons' | 'prefixAddons' | 'suffixAddons'> & {
-    readonly addons: Signal<ReadonlyArray<TAddon> | undefined>;
-    readonly visibleAddons: Signal<ReadonlyArray<TAddon>>;
-    readonly prefixAddons: Signal<ReadonlyArray<TAddon>>;
-    readonly suffixAddons: Signal<ReadonlyArray<TAddon>>;
+  readonly addons: Signal<ReadonlyArray<TAddon> | undefined>;
+  readonly visibleAddons: Signal<ReadonlyArray<TAddon>>;
+  readonly prefixAddons: Signal<ReadonlyArray<TAddon>>;
+  readonly suffixAddons: Signal<ReadonlyArray<TAddon>>;
 };
 /**
  * Typed inject helper. Always resolves to the underlying
  * `NgForgeAddonsBase` instance — the wrapper class has no instance
  * fields of its own.
  */
-declare function injectNgForgeAddons<TAddon extends AnyAddon = AnyAddon>(): TypedNgForgeAddons<TAddon>;
-
+export declare function injectNgForgeAddons<TAddon extends AnyAddon = AnyAddon>(): TypedNgForgeAddons<TAddon>;
 /**
  * Permissive shape the directive reads from `addon()`. Adapter-specific
  * addon types (e.g., `PrimeButtonAddon`) narrow this at the inject site via
  * `injectNgForgeAddonAction<T>()`.
  */
 interface ActionAddonShape extends BaseAddon {
-    readonly preset?: string;
-    readonly actionRef?: string;
-    readonly action?: AddonActionHandler;
-    readonly disabled?: DynamicValue<boolean>;
-    readonly loading?: DynamicValue<boolean>;
+  readonly preset?: string;
+  readonly actionRef?: string;
+  readonly action?: AddonActionHandler$1;
+  readonly disabled?: DynamicValue<boolean>;
+  readonly loading?: DynamicValue<boolean>;
 }
 /**
  * Universal click-dispatch plumbing for action-style addons (icon buttons,
@@ -771,59 +841,76 @@ interface ActionAddonShape extends BaseAddon {
  * `DynamicValue<boolean>`, action context construction, and the
  * `preset / actionRef / action` precedence dispatcher.
  */
-declare class NgForgeAddonActionBase {
-    private readonly actionRegistry;
-    private readonly presetHandler;
-    private readonly logger;
-    private readonly hostInjector;
-    readonly addon: i0.InputSignal<ActionAddonShape>;
-    readonly fieldInputs: i0.InputSignal<WrapperFieldInputs | undefined>;
-    /**
-     * Per-value caches for `disabled` / `loading` signal resolution. Keyed by
-     * the `DynamicValue` identity so a single `toSignal` subscription is
-     * shared across addon-reference swaps that pass the same Observable.
-     * Mirrors `NgForgeAddonsBase._hiddenByValue` — `resolveDynamicValue`
-     * cannot run inside `computed`/`linkedSignal.computation` because
-     * `toSignal` throws in reactive contexts (NG0602), and re-running it on
-     * every recomputation would leak subscriptions on each cycle.
-     */
-    private readonly _disabledByValue;
-    private readonly _loadingByValue;
-    private readonly _resolvedDisabled;
-    private readonly _resolvedLoading;
-    readonly disabled: Signal<boolean>;
-    readonly loading: Signal<boolean>;
-    constructor();
-    private _resolveAxis;
-    /**
-     * Resolve the click handler from the addon's three-axis click variant and
-     * invoke it. Precedence on multi-set: `preset > actionRef > action`. The
-     * validator drops multi-set configs at config-init time; this is
-     * defence-in-depth + a logged warning so the misconfiguration is loud.
-     */
-    dispatch(): void;
-    /**
-     * Build an `AddonActionContext` for handlers from the wrapper-style
-     * `fieldInputs` bag. Returns the field-bound variant when a host field
-     * is reachable, or the orphan variant otherwise.
-     */
-    buildActionContext(): AddonActionContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddonActionBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddonActionBase, never, never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NgForgeAddonActionBase {
+  private readonly actionRegistry;
+  private readonly presetHandler;
+  private readonly logger;
+  private readonly hostInjector;
+  readonly addon: import("@angular/core").InputSignal<ActionAddonShape>;
+  readonly fieldInputs: import("@angular/core").InputSignal<WrapperFieldInputs$1 | undefined>;
+  /**
+   * Per-value caches for `disabled` / `loading` signal resolution. Keyed by
+   * the `DynamicValue` identity so a single `toSignal` subscription is
+   * shared across addon-reference swaps that pass the same Observable.
+   * Mirrors `NgForgeAddonsBase._hiddenByValue` — `resolveDynamicValue`
+   * cannot run inside `computed`/`linkedSignal.computation` because
+   * `toSignal` throws in reactive contexts (NG0602), and re-running it on
+   * every recomputation would leak subscriptions on each cycle.
+   */
+  private readonly _disabledByValue;
+  private readonly _loadingByValue;
+  private readonly _resolvedDisabled;
+  private readonly _resolvedLoading;
+  readonly disabled: Signal<boolean>;
+  readonly loading: Signal<boolean>;
+  constructor();
+  private _resolveAxis;
+  /**
+   * Resolve the click handler from the addon's three-axis click variant and
+   * invoke it. Precedence on multi-set: `preset > actionRef > action`. The
+   * validator drops multi-set configs at config-init time; this is
+   * defence-in-depth + a logged warning so the misconfiguration is loud.
+   */
+  dispatch(): void;
+  /**
+   * Build an `AddonActionContext` for handlers from the wrapper-style
+   * `fieldInputs` bag. Returns the field-bound variant when a host field
+   * is reachable, or the orphan variant otherwise.
+   */
+  buildActionContext(): AddonActionContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddonActionBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddonActionBase, never, never, {
+    "addon": {
+      "alias": "addon";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldInputs": {
+      "alias": "fieldInputs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /** Forwarded onto `NgForgeAddonActionBase` via the `NgForgeAddonAction` wrapper. */
-declare const NG_FORGE_ADDON_ACTION_INPUTS: readonly ["addon", "fieldInputs"];
+export declare const NG_FORGE_ADDON_ACTION_INPUTS: readonly ["addon", "fieldInputs"];
 /** Host wrapper for `NgForgeAddonActionBase`. Consumers compose this directly: */
-declare class NgForgeAddonAction {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddonAction, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddonAction, never, never, {}, {}, never, never, true, [{ directive: typeof NgForgeAddonActionBase; inputs: { "addon": "addon"; "fieldInputs": "fieldInputs"; }; outputs: {}; }]>;
+export declare class NgForgeAddonAction {
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeAddonAction, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeAddonAction, never, never, {}, {}, never, never, true, [{
+    directive: typeof NgForgeAddonActionBase;
+    inputs: {
+      "addon": "addon";
+      "fieldInputs": "fieldInputs";
+    };
+    outputs: {};
+  }]>;
 }
 /** Narrowed view of `NgForgeAddonActionBase` returned by `injectNgForgeAddonAction<T>()`. */
 type TypedNgForgeAddonAction<TAddon extends ActionAddonShape = ActionAddonShape> = Omit<NgForgeAddonActionBase, 'addon'> & {
-    readonly addon: Signal<TAddon>;
+  readonly addon: Signal<TAddon>;
 };
-declare function injectNgForgeAddonAction<TAddon extends ActionAddonShape = ActionAddonShape>(): TypedNgForgeAddonAction<TAddon>;
-
+export declare function injectNgForgeAddonAction<TAddon extends ActionAddonShape = ActionAddonShape>(): TypedNgForgeAddonAction<TAddon>;
 /**
  * Adapter-supplied resolver for `preset` addon actions (e.g., `'clear'`,
  * `'toggle-password-visibility'`). The universal click-dispatch directive
@@ -832,10 +919,9 @@ declare function injectNgForgeAddonAction<TAddon extends ActionAddonShape = Acti
  * provider scope.
  */
 interface AddonPresetHandler {
-    run(preset: string, ctx: AddonActionContext): void | Promise<void>;
+  run(preset: string, ctx: AddonActionContext): void | Promise<void>;
 }
-declare const ADDON_PRESET_HANDLER: InjectionToken<AddonPresetHandler>;
-
+export declare const ADDON_PRESET_HANDLER: InjectionToken<AddonPresetHandler>;
 /**
  * Marker directive applied to the canonical control element of an
  * `NgForgeField`-using component. Forwards the field's `meta` AND
@@ -850,11 +936,17 @@ declare const ADDON_PRESET_HANDLER: InjectionToken<AddonPresetHandler>;
  * Each `@for` iteration creates its own directive instance; Angular's
  * structural lifecycle handles add/remove naturally.
  */
-declare class NgForgeControl {
-    readonly target: i0.InputSignal<string | undefined>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeControl, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeControl, "[ngForgeControl]", never, { "target": { "alias": "ngForgeControl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NgForgeControl {
+  readonly target: import("@angular/core").InputSignal<string | undefined>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeControl, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeControl, "[ngForgeControl]", never, {
+    "target": {
+      "alias": "ngForgeControl";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /**
  * Selectorless companion directive for shadow-DOM-encapsulated components
@@ -862,31 +954,67 @@ declare class NgForgeControl {
  * is the canonical control. Added to the component's `hostDirectives` so the
  * field's `meta` + parent aria land on the component's own host element.
  */
-declare class NgForgeHostControl {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeHostControl, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeHostControl, never, never, {}, {}, never, never, true, never>;
+export declare class NgForgeHostControl {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeHostControl, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeHostControl, never, never, {}, {}, never, never, true, never>;
 }
-
 /**
  * Value-bearing field host wrapper. Composes `NgForgeFieldShell` (universal
  * identity) with `NgForgeField` (value + validation + aria + meta-tracking)
  * in a single host-directive entry, so consumer components compose just one
  * directive instead of two.
  */
-declare class NgForgeFieldHost {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeFieldHost, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeFieldHost, never, never, {}, {}, never, never, true, [{ directive: typeof NgForgeFieldShell; inputs: { "key": "key"; "className": "className"; }; outputs: {}; }, { directive: typeof NgForgeField; inputs: { "field": "field"; "label": "label"; "placeholder": "placeholder"; "tabIndex": "tabIndex"; "props": "props"; "meta": "meta"; "validationMessages": "validationMessages"; }; outputs: {}; }]>;
+export declare class NgForgeFieldHost {
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeFieldHost, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeFieldHost, never, never, {}, {}, never, never, true, [{
+    directive: typeof NgForgeFieldShell;
+    inputs: {
+      "key": "key";
+      "className": "className";
+    };
+    outputs: {};
+  }, {
+    directive: typeof NgForgeField;
+    inputs: {
+      "field": "field";
+      "label": "label";
+      "placeholder": "placeholder";
+      "tabIndex": "tabIndex";
+      "props": "props";
+      "meta": "meta";
+      "validationMessages": "validationMessages";
+    };
+    outputs: {};
+  }]>;
 }
 /**
  * Action / button host wrapper. Composes `NgForgeFieldShell` with
  * `NgForgeAction` (event dispatch + aria-disabled) for button-shaped
  * components.
  */
-declare class NgForgeActionHost {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeActionHost, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeActionHost, never, never, {}, {}, never, never, true, [{ directive: typeof NgForgeFieldShell; inputs: { "key": "key"; "className": "className"; }; outputs: {}; }, { directive: typeof NgForgeAction; inputs: { "label": "label"; "disabled": "disabled"; "hidden": "hidden"; "tabIndex": "tabIndex"; "event": "event"; "eventArgs": "eventArgs"; "eventContext": "eventContext"; "props": "props"; }; outputs: {}; }]>;
+export declare class NgForgeActionHost {
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgForgeActionHost, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NgForgeActionHost, never, never, {}, {}, never, never, true, [{
+    directive: typeof NgForgeFieldShell;
+    inputs: {
+      "key": "key";
+      "className": "className";
+    };
+    outputs: {};
+  }, {
+    directive: typeof NgForgeAction;
+    inputs: {
+      "label": "label";
+      "disabled": "disabled";
+      "hidden": "hidden";
+      "tabIndex": "tabIndex";
+      "event": "event";
+      "eventArgs": "eventArgs";
+      "eventContext": "eventContext";
+      "props": "props";
+    };
+    outputs: {};
+  }]>;
 }
-
-export { ADDON_PRESET_HANDLER, NG_FORGE_ACTION_INPUTS, NG_FORGE_ADDONS_INPUTS, NG_FORGE_ADDON_ACTION_INPUTS, NG_FORGE_FIELD_SHELL_INPUTS, NG_FORGE_VALUE_FIELD_INPUTS, NgForgeAction, NgForgeActionHost, NgForgeAddonAction, NgForgeAddonActionBase, NgForgeAddons, NgForgeAddonsBase, NgForgeControl, NgForgeField, NgForgeFieldHost, NgForgeFieldShell, NgForgeHostControl, addArrayItemButtonMapper, buildArrayButtonEventContext, buildValueFieldInputs, buttonFieldMapper, checkboxFieldMapper, createAriaDescribedBySignal, datepickerFieldMapper, injectNgForgeAction, injectNgForgeAddonAction, injectNgForgeAddons, injectNgForgeField, injectNonFieldLogicResolver, insertArrayItemButtonMapper, nextButtonFieldMapper, optionsFieldMapper, popArrayItemButtonMapper, prependArrayItemButtonMapper, previousButtonFieldMapper, removeArrayItemButtonMapper, resolveArrayButtonContext, resolveArrayButtonEventArgs, resolveValueFieldContext, setupMetaTracking, shiftArrayItemButtonMapper, submitButtonFieldMapper, valueFieldMapper };
-export type { AddonPresetHandler, ArrayButtonContext, ArrayButtonEventContext, Autocapitalize, AutocompleteValue, BaseArrayAddButtonField, BaseArrayRemoveButtonField, BaseInsertArrayItemButtonField, BaseNavigationButtonField, ButtonField, CheckboxField, DatepickerField, DatepickerProps, EnterKeyHint, EventArg, EventArgs, FieldWithOptions, HtmlInputType, InferInputValue, InputField, InputMeta, InputMode, InputProps, InputType, MetaTrackingOptions, MultiCheckboxField, NumericInputType, RadioField, SelectField, SelectProps, SliderField, StringInputType, TextareaField, TextareaMeta, TextareaProps, TextareaWrap, ToggleField, TypedNgForgeAddonAction, TypedNgForgeAddons, TypedNgForgeField, ValueFieldContext };
+export { ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, type AddonActionHandler, type AddonPresetHandler, type AddonShapeValidator, type AddonTypeDefinition, type AddonTypeSchema, type ArrayButtonContext, type ArrayButtonEventContext, type ArrayContext, type ArrayFieldTree, type Autocapitalize, type AutocompleteValue, BUILT_IN_FIELDS, type BaseArrayAddButtonField, type BaseArrayRemoveButtonField, type BaseInsertArrayItemButtonField, type BaseNavigationButtonField, type ButtonField, type CheckboxField, type CheckedFieldComponent, type CreateNgForgeActionFixtureOptions, type CreateNgForgeFieldFixtureOptions, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, type DatepickerField, type DatepickerProps, DfAddonSlot, DynamicTextPipe, type EnterKeyHint, type EventArg, type EventArgs, EventBus, FIELD_ERROR_DISPLAY, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, type FieldAddonSupport, type FieldAddonSupportEntry, type FieldErrorDisplayClaim, type FieldErrors, type FieldErrorsOptions, FieldErrorsWrapperBase, type FieldScope, type FieldSignalContext, type FieldStateContext, type FieldStateInfo, type FieldTypeDefinition, type FieldWithOptions, type FieldWrapper, type FormFieldStateMap, GROUP_CONTEXT, type HtmlInputType, type HttpResourceRequest, INITIALIZATION_TIMEOUT_MS, type InferInputValue, type InferWrapperRegistry, type InputField, type InputMeta, type InputMode, type InputProps, type InputType, type MapperFn, type MetaTrackingOptions, type MultiCheckboxField, type NgForgeActionFixture, type NgForgeFieldFixture, type NonFieldLogicConfig, type NonFieldLogicContext, type NonFieldLogicType, type NumericInputType, type PresetCollaborators, type RadioField, type ReadonlyFieldTree, type ResolvedError, RootFormRegistryService, type SelectField, type SelectProps, type SliderField, type StringInputType, type TextareaField, type TextareaMeta, type TextareaProps, type TextareaWrap, type ToggleField, type TypedNgForgeAddonAction, type TypedNgForgeAddons, type TypedNgForgeField, type ValueFieldComponent, type ValueFieldContext, type ValueHandlingMode, type WrapperFieldInputs, type WrapperRegistration, type WrapperTypeDefinition, type WrappersBundle, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, containerFieldMapper, createNgForgeActionFixture, createNgForgeFieldFixture, createResolvedErrorsSignal, createWrappers, dynamicTextToObservable, getArrayLength, groupFieldMapper, injectAddonTypeRegistry, injectFieldErrors, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isCheckedField, isEqual, isValueField, isWrappersBundle, pageFieldMapper, provideFieldErrorDisplay, provideTestValidationMessages, resolveDynamicValue, resolveNonFieldDisabled, resolveNonFieldHidden, resolveTokens, rowFieldMapper, runPresetAction, shouldShowErrors, textFieldMapper, toReadonlyFieldTree, withPreviousValue, wrapperProps, writeToFieldValue };