@ng-forge/dynamic-forms 0.1.0

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

@@ -0,0 +1,3462 @@
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as _angular_forms from '@angular/forms';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { ValidationError as ValidationError$1, FieldContext, TreeValidationResult, FieldTree, Schema, form, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
+import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
+import * as _angular_core from '@angular/core';
+import { Signal, ResourceRef, Injector, WritableSignal, InjectionToken, Type, OnDestroy, InputSignal, EnvironmentProviders, PipeTransform } from '@angular/core';
+
+type WithInputSignals<T> = {
+    readonly [K in keyof T]-?: Signal<T[K]>;
+};
+
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+type DynamicText = string | Observable<string> | Signal<string>;
+
+/**
+ * Base interface for all dynamic form field definitions.
+ *
+ * This interface defines the common properties that all field types must implement.
+ * Field-specific properties are defined through the generic TProps parameter,
+ * providing type safety for field-specific configuration.
+ *
+ * @example
+ * ```typescript
+ * // Basic text input field
+ * const textField: FieldDef<{ placeholder: string }> = {
+ *   key: 'email',
+ *   type: 'input',
+ *   label: 'Email Address',
+ *   props: { placeholder: 'Enter your email' },
+ *   col: 12
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Complex field with conditional logic
+ * const conditionalField: FieldDef<SelectProps> = {
+ *   key: 'country',
+ *   type: 'select',
+ *   label: 'Country',
+ *   props: {
+ *     options: [
+ *       { label: 'United States', value: 'us' },
+ *       { label: 'Canada', value: 'ca' }
+ *     ]
+ *   },
+ *   hidden: false,
+ *   disabled: false,
+ *   col: 6
+ * };
+ * ```
+ *
+ * @typeParam TProps - Field-specific properties interface
+ *
+ * @public
+ */
+interface FieldDef<TProps> {
+    /**
+     * Unique field identifier used for form binding and value tracking.
+     *
+     * This key is used to associate the field with form values and must be
+     * unique within the form. It follows object property naming conventions.
+     *
+     * @example
+     * ```typescript
+     * // Simple field key
+     * key: 'email'
+     *
+     * // Nested object notation
+     * key: 'address.street'
+     *
+     * // Array notation
+     * key: 'hobbies[0]'
+     * ```
+     */
+    key: string;
+    /**
+     * Field type identifier for component selection.
+     *
+     * Determines which component will be rendered for this field.
+     * Must match a registered field type name in the field registry.
+     *
+     * @example
+     * ```typescript
+     * type: 'input'     // Text input field
+     * type: 'select'    // Dropdown selection
+     * type: 'checkbox'  // Boolean checkbox
+     * type: 'group'     // Field group container
+     * ```
+     */
+    type: string;
+    /**
+     * Human-readable field label displayed to users.
+     *
+     * Provides accessible labeling for form fields and is typically
+     * displayed above or beside the field input. Supports static strings,
+     * translation keys, Observables, and Signals for dynamic content.
+     *
+     * @example
+     * ```typescript
+     * // Static string
+     * label: 'Email Address'
+     *
+     * // Translation key (auto-detected)
+     * label: 'form.email.label'
+     *
+     * // Observable from translation service
+     * label: this.transloco.selectTranslate('form.email.label')
+     *
+     * // Signal-based
+     * label: computed(() => this.translations().email.label)
+     * ```
+     */
+    label?: DynamicText;
+    /**
+     * Field-specific properties and configuration options.
+     *
+     * Contains type-specific configuration that varies based on the field type.
+     * The shape is defined by the TProps generic parameter.
+     *
+     * @example
+     * ```typescript
+     * // Input field props
+     * props: { placeholder: 'Enter email', type: 'email' }
+     *
+     * // Select field props
+     * props: { options: [{ label: 'Yes', value: true }], multiple: false }
+     *
+     * // Button field props
+     * props: { buttonType: 'submit', variant: 'primary' }
+     * ```
+     */
+    props?: TProps;
+    /**
+     * Additional CSS classes for custom styling.
+     *
+     * Space-separated string of CSS class names that will be applied
+     * to the field container for custom styling.
+     *
+     * @example
+     * ```typescript
+     * className: 'highlight required-field'
+     * className: 'mt-4 text-center'
+     * ```
+     */
+    className?: string;
+    /**
+     * Whether the field is disabled and cannot be interacted with.
+     *
+     * When true, the field is rendered in a disabled state and cannot
+     * receive user input. The value can still be modified programmatically.
+     *
+     * @value false
+     */
+    disabled?: boolean;
+    /**
+     * Whether the field is read-only.
+     *
+     * When true, the field displays its value but cannot be modified
+     * by user interaction. Differs from disabled in styling and accessibility.
+     *
+     * @value false
+     */
+    readonly?: boolean;
+    /**
+     * Whether the field is hidden from view.
+     *
+     * When true, the field is not rendered in the UI but still participates
+     * in form state and validation. Useful for conditional field display.
+     *
+     * @value false
+     */
+    hidden?: boolean;
+    /**
+     * Tab index for keyboard navigation.
+     *
+     * Controls the order in which fields receive focus when navigating
+     * with the Tab key. Follows standard HTML tabindex behavior.
+     *
+     * @example
+     * ```typescript
+     * tabIndex: 1    // First field in tab order
+     * tabIndex: -1   // Excluded from tab navigation
+     * tabIndex: 0    // Natural tab order
+     * ```
+     */
+    tabIndex?: number | undefined;
+    /**
+     * Column sizing configuration for responsive grid layout.
+     *
+     * Specifies how many columns this field should span in a 12-column
+     * grid system. Supports responsive behavior and field arrangement.
+     *
+     * @example
+     * ```typescript
+     * col: 12  // Full width
+     * col: 6   // Half width
+     * col: 4   // One third width
+     * col: 3   // Quarter width
+     * ```
+     *
+     * @value 12
+     */
+    col?: number;
+}
+type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
+/**
+ * Type utility for extracting component input properties from field definitions.
+ *
+ * Transforms field definition properties into Angular component input signals,
+ * enabling type-safe component binding with automatic signal creation.
+ *
+ * @example
+ * ```typescript
+ * // Field definition
+ * interface MyFieldDef extends FieldDef<MyProps> {
+ *   customProp: string;
+ * }
+ *
+ * // Component using FieldComponent type
+ * @Component({...})
+ * export class MyFieldComponent implements FieldComponent<MyFieldDef> {
+ *   label = input<string>();
+ *   className = input<string>();
+ *   hidden = input<boolean>();
+ *   tabIndex = input<number>();
+ * }
+ * ```
+ *
+ * @typeParam T - Field definition type to extract properties from
+ *
+ * @public
+ */
+type FieldComponent<T extends FieldDef<any>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
+
+/**
+ * Re-export Angular's ValidationError for consistency
+ * This replaces our custom ValidationError interface
+ */
+type ValidationError = ValidationError$1;
+interface ValidationMessages {
+    required?: DynamicText;
+    email?: DynamicText;
+    min?: DynamicText;
+    max?: DynamicText;
+    minLength?: DynamicText;
+    maxLength?: DynamicText;
+    pattern?: DynamicText;
+    [key: string]: DynamicText | undefined;
+}
+
+/**
+ * Row field interface for creating horizontal layouts
+ * This is a special field type that contains other definitions arranged horizontally
+ * The row itself doesn't have a value - it's a layout container
+ * This is a programmatic field type only - users cannot customize this field type
+ *
+ * TypeScript cannot enforce field nesting rules due to circular dependency limitations.
+ * For documentation: Rows should contain groups and leaf fields, but NOT pages or other rows.
+ * Runtime validation enforces these rules.
+ */
+interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowAllowedChildren[]> extends FieldDef<never> {
+    type: 'row';
+    /** Child definitions to render within this row */
+    readonly fields: TFields;
+    /** Row fields do not have a label property **/
+    readonly label?: never;
+}
+/**
+ * Type guard for RowField with proper type narrowing
+ */
+declare function isRowField(field: FieldDef<any>): field is RowField;
+
+/**
+ * Group field interface for creating logical field groupings that map to object values
+ * Groups create nested form structures where child field values are collected into an object
+ * This is a programmatic grouping only - users cannot customize this field type
+ *
+ * TypeScript cannot enforce field nesting rules due to circular dependency limitations.
+ * For documentation: Groups should contain rows and leaf fields, but NOT pages or other groups.
+ * Runtime validation enforces these rules.
+ */
+interface GroupField<TFields extends readonly GroupAllowedChildren[] = readonly GroupAllowedChildren[]> extends FieldDef<never> {
+    type: 'group';
+    readonly fields: TFields;
+    /** Groups do not have a label property - they are logical containers only **/
+    readonly label?: never;
+}
+/**
+ * Type guard for GroupField with proper type narrowing
+ */
+declare function isGroupField(field: FieldDef<any>): field is GroupField;
+
+/**
+ * Type constraints for field nesting rules
+ * These ensure that container fields can only contain valid child field types
+ *
+ * Note: We explicitly list types instead of using Exclude to avoid circular dependencies
+ */
+/**
+ * Fields that are allowed as children of Page fields
+ * Pages can contain: rows, groups, arrays, and leaf fields (but NOT other pages)
+ */
+type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField;
+/**
+ * Fields that are allowed as children of Row fields
+ * Rows can contain: groups, arrays, and leaf fields (but NOT pages or other rows)
+ */
+type RowAllowedChildren = LeafFieldTypes | GroupField | ArrayField;
+/**
+ * Fields that are allowed as children of Group fields
+ * Groups can contain: rows and leaf fields (but NOT pages or other groups)
+ */
+type GroupAllowedChildren = LeafFieldTypes | RowField;
+/**
+ * Fields that are allowed as children of Array fields
+ * Arrays can contain: rows, groups, and leaf fields (but NOT pages or other arrays)
+ * Groups are used for creating object arrays where each array item is an object
+ */
+type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField;
+
+/**
+ * Array field interface for creating dynamic field collections that map to array values.
+ *
+ * Key concepts:
+ * - The `fields` array defines the TEMPLATE (single field definition), not instances
+ * - Array items are created/removed dynamically at runtime via event bus
+ * - For primitive arrays: Use a leaf field as template → `['value1', 'value2']`
+ * - For object arrays: Use a group field as template → `[{key1: val1}, {key2: val2}]`
+ *
+ * @example
+ * // Primitive array (flat values)
+ * {
+ *   key: 'tags',
+ *   type: 'array',
+ *   fields: [{ key: 'tag', type: 'input' }]
+ * }
+ * // Creates: { tags: ['tag1', 'tag2', 'tag3'] }
+ *
+ * @example
+ * // Object array (nested groups)
+ * {
+ *   key: 'contacts',
+ *   type: 'array',
+ *   fields: [{
+ *     type: 'group',
+ *     fields: [
+ *       { key: 'name', type: 'input' },
+ *       { key: 'email', type: 'input' }
+ *     ]
+ *   }]
+ * }
+ * // Creates: { contacts: [{name: '', email: ''}, {name: '', email: ''}] }
+ *
+ * Nesting constraints: Arrays can contain rows, leaf fields, or groups (for object arrays),
+ * but NOT pages or other arrays. Runtime validation enforces these rules.
+ */
+interface ArrayField<TFields extends readonly ArrayAllowedChildren[] = readonly ArrayAllowedChildren[]> extends FieldDef<never> {
+    type: 'array';
+    /**
+     * Template field definition(s) that will be cloned for each array item.
+     * Typically contains a single field definition:
+     * - For flat arrays: A leaf field (input, select, checkbox, etc.)
+     * - For object arrays: A group field containing multiple child fields
+     */
+    readonly fields: TFields;
+    /** Array fields do not have a label property **/
+    readonly label?: never;
+}
+/**
+ * Type guard for ArrayField with proper type narrowing
+ */
+declare function isArrayField(field: FieldDef<any>): field is ArrayField;
+
+interface ConditionalExpression {
+    /** Expression type */
+    type: 'fieldValue' | 'formValue' | 'custom' | 'javascript' | 'and' | 'or';
+    /** Field path for fieldValue type */
+    fieldPath?: string;
+    /** Comparison operator */
+    operator?: 'equals' | 'notEquals' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual' | 'contains' | 'startsWith' | 'endsWith' | 'matches';
+    /** Value to compare against */
+    value?: unknown;
+    /** JavaScript expression for custom logic */
+    expression?: string;
+    /** Array of sub-conditions for 'and' and 'or' types */
+    conditions?: ConditionalExpression[];
+}
+
+/**
+ * Logic configuration for page fields.
+ * Pages only support the 'hidden' logic type since they are layout containers,
+ * not form controls (they can't be readonly, disabled, or required).
+ */
+interface PageLogicConfig {
+    /** Only 'hidden' is supported for pages */
+    type: 'hidden';
+    /**
+     * Condition that determines when this page is hidden.
+     * Can be a boolean or a conditional expression evaluated against form values.
+     */
+    condition: ConditionalExpression | boolean;
+}
+/**
+ * Page field interface for creating top-level page layouts
+ * This is a special field type that contains other field definitions
+ * The page itself doesn't have a value - it's a layout container like row
+ * Pages can only be used at the top level and cannot be nested
+ * This is a programmatic field type only - users cannot customize this field type
+ *
+ * TypeScript cannot enforce field nesting rules due to circular dependency limitations.
+ * For documentation: Pages should contain rows, groups, and leaf fields, but NOT other pages.
+ * Runtime validation enforces these rules.
+ */
+interface PageField<TFields extends readonly PageAllowedChildren[] = PageAllowedChildren[]> extends FieldDef<never> {
+    type: 'page';
+    /** Child field definitions to render within this page */
+    readonly fields: TFields;
+    /** Page fields do not have a label property **/
+    readonly label?: never;
+    /**
+     * Logic configurations for conditional page visibility.
+     * Only 'hidden' type logic is supported for pages.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   key: 'businessPage',
+     *   type: 'page',
+     *   logic: [{
+     *     type: 'hidden',
+     *     condition: {
+     *       type: 'fieldValue',
+     *       fieldPath: 'accountType',
+     *       operator: 'notEquals',
+     *       value: 'business',
+     *     },
+     *   }],
+     *   fields: [...]
+     * }
+     * ```
+     */
+    readonly logic?: PageLogicConfig[];
+}
+/**
+ * Type guard for PageField with proper type narrowing
+ */
+declare function isPageField(field: FieldDef<unknown>): field is PageField;
+
+/**
+ * Special form-state conditions for button disabled logic.
+ *
+ * These conditions evaluate form or page-level state rather than field values,
+ * and are primarily used for controlling button disabled states.
+ *
+ * @example
+ * ```typescript
+ * // Disable submit button when form is invalid or submitting
+ * {
+ *   key: 'submit',
+ *   type: 'submit',
+ *   label: 'Submit',
+ *   logic: [
+ *     { type: 'disabled', condition: 'formInvalid' },
+ *     { type: 'disabled', condition: 'formSubmitting' },
+ *   ]
+ * }
+ *
+ * // Disable next button when current page is invalid
+ * nextButton({
+ *   key: 'next',
+ *   label: 'Next',
+ *   logic: [
+ *     { type: 'disabled', condition: 'pageInvalid' },
+ *   ]
+ * })
+ * ```
+ *
+ * @public
+ */
+type FormStateCondition = 
+/** True when form.valid() === false */
+'formInvalid'
+/** True when form.submitting() === true */
+ | 'formSubmitting'
+/** True when fields on the current page are invalid (for paged forms) */
+ | 'pageInvalid';
+/**
+ * Configuration for conditional field logic.
+ *
+ * Defines how field behavior changes based on conditions.
+ * Supports hiding, disabling, making readonly, or requiring fields
+ * based on form state or field values.
+ *
+ * @example
+ * ```typescript
+ * // Hide email field when contact method is not email
+ * {
+ *   type: 'hidden',
+ *   condition: {
+ *     type: 'fieldValue',
+ *     fieldPath: 'contactMethod',
+ *     operator: 'notEquals',
+ *     value: 'email'
+ *   }
+ * }
+ *
+ * // Disable button when form is submitting
+ * {
+ *   type: 'disabled',
+ *   condition: 'formSubmitting'
+ * }
+ * ```
+ *
+ * @public
+ */
+interface LogicConfig {
+    /**
+     * Logic type identifier.
+     *
+     * - `hidden`: Hide the field from view (still participates in form state)
+     * - `readonly`: Make the field read-only
+     * - `disabled`: Disable user interaction
+     * - `required`: Make the field required
+     */
+    type: 'hidden' | 'readonly' | 'disabled' | 'required';
+    /**
+     * Condition that determines when this logic applies.
+     *
+     * Can be:
+     * - `boolean`: Static value (always applies or never applies)
+     * - `ConditionalExpression`: Expression evaluated against field/form values
+     * - `FormStateCondition`: Special form/page state check (for buttons)
+     *
+     * @example
+     * ```typescript
+     * // Static condition
+     * condition: true
+     *
+     * // Field value condition
+     * condition: {
+     *   type: 'fieldValue',
+     *   fieldPath: 'status',
+     *   operator: 'equals',
+     *   value: 'locked'
+     * }
+     *
+     * // Form state condition (for buttons)
+     * condition: 'formSubmitting'
+     * ```
+     */
+    condition: ConditionalExpression | boolean | FormStateCondition;
+}
+/**
+ * Type guard to check if a condition is a FormStateCondition.
+ *
+ * @param condition - The condition to check
+ * @returns true if the condition is a FormStateCondition
+ *
+ * @public
+ */
+declare function isFormStateCondition(condition: LogicConfig['condition']): condition is FormStateCondition;
+
+/**
+ * Text element type for rendering different HTML text elements
+ */
+type TextElementType = 'p' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span';
+/**
+ * Properties for text field configuration
+ */
+type TextProps = {
+    /** The HTML element type to render */
+    elementType: TextElementType;
+};
+/**
+ * Text field definition for displaying translatable text content
+ */
+interface TextField extends FieldDef<TextProps> {
+    type: 'text';
+    /** Logic rules for conditional visibility (hidden, readonly, disabled) */
+    readonly logic?: LogicConfig[];
+}
+
+/**
+ * Container fields registry - augment this interface to add custom container fields
+ *
+ * @example
+ * ```typescript
+ * declare module '@ng-forge/dynamic-forms' {
+ *   interface FieldRegistryContainers {
+ *     'my-container': MyContainerFieldDef;
+ *   }
+ * }
+ * ```
+ */
+interface FieldRegistryContainers {
+    page: PageField;
+    row: RowField;
+    group: GroupField;
+    array: ArrayField;
+}
+/**
+ * Leaf fields registry - augment this interface to add custom leaf fields
+ *
+ * @example
+ * ```typescript
+ * declare module '@ng-forge/dynamic-forms' {
+ *   interface FieldRegistryLeaves {
+ *     'my-input': MyInputFieldDef;
+ *   }
+ * }
+ * ```
+ */
+interface FieldRegistryLeaves {
+    text: TextField;
+}
+/**
+ * Global interface for dynamic form field definitions with categorization
+ * This interface combines containers and leaves from their respective registries
+ *
+ * Container fields: Layout fields that contain other fields (page, row, group, array)
+ * Leaf fields: Fields that can hold values or display content (input, text, etc.)
+ *
+ * To add custom fields, augment FieldRegistryContainers or FieldRegistryLeaves
+ */
+interface DynamicFormFieldRegistry {
+    /**
+     * Container fields that hold other fields (no value, have children)
+     */
+    containers: FieldRegistryContainers;
+    /**
+     * Leaf fields that have values or display content
+     */
+    leaves: FieldRegistryLeaves;
+}
+/**
+ * Union type of all registered container field definitions
+ */
+type ContainerFieldTypes = DynamicFormFieldRegistry['containers'][keyof DynamicFormFieldRegistry['containers']];
+/**
+ * Union type of all registered leaf field definitions
+ */
+type LeafFieldTypes = DynamicFormFieldRegistry['leaves'][keyof DynamicFormFieldRegistry['leaves']];
+/**
+ * Union type of all registered field definitions
+ */
+type RegisteredFieldTypes = ContainerFieldTypes | LeafFieldTypes;
+/**
+ * Extract field types that are available in the registry
+ */
+type AvailableFieldTypes = keyof DynamicFormFieldRegistry['containers'] | keyof DynamicFormFieldRegistry['leaves'];
+
+/**
+ * Helper type to convert union to intersection
+ * Note: `any` is necessary for distributive conditional types
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Depth counter for recursion limiting (prevents infinite type instantiation)
+ */
+type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+/**
+ * Process a single field and determine its contribution to the form value type
+ * Handles:
+ * - Page fields: flatten children (valueHandling: 'flatten')
+ * - Row fields: flatten children (valueHandling: 'flatten')
+ * - Group fields: nest children under group key (valueHandling: 'include')
+ * - Text fields: exclude from values (valueHandling: 'exclude')
+ * - Value fields: include with their key and value type
+ */
+type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string, unknown> : T extends {
+    type: 'page';
+    fields: infer TFields;
+} ? TFields extends RegisteredFieldTypes[] ? InferFormValueWithDepth<TFields, Depth[D]> : never : T extends {
+    type: 'row';
+    fields: infer TFields;
+} ? TFields extends RegisteredFieldTypes[] ? InferFormValueWithDepth<TFields, Depth[D]> : never : T extends {
+    type: 'group';
+    key: infer K;
+    fields: infer TFields;
+} ? K extends string ? TFields extends RegisteredFieldTypes[] ? {
+    [P in K]: InferFormValueWithDepth<TFields, Depth[D]>;
+} : {
+    [P in K]: Record<string, unknown>;
+} : never : T extends {
+    type: 'text';
+} ? never : T extends {
+    key: infer K;
+    value: infer V;
+    required: true;
+} ? K extends string ? {
+    [P in K]: V;
+} : never : T extends {
+    key: infer K;
+    value: infer V;
+} ? K extends string ? {
+    [P in K]: V | undefined;
+} : never : never;
+/**
+ * Internal helper with depth tracking
+ */
+type InferFormValueWithDepth<T extends RegisteredFieldTypes[], D extends number = 5> = UnionToIntersection<ProcessField<T[number], D>>;
+/**
+ * Infer form value type from an array of field definitions
+ * Recursively processes nested structures and merges the results
+ * Limited to 5 levels of nesting to prevent infinite type instantiation
+ *
+ * @example
+ * ```typescript
+ * const fields = [
+ *   { type: 'input', key: 'email', value: '', required: true },
+ *   { type: 'group', key: 'address', fields: [
+ *     { type: 'input', key: 'street', value: '' },
+ *     { type: 'input', key: 'city', value: '' }
+ *   ]}
+ * ] as const;
+ *
+ * type FormValue = InferFormValue<typeof fields>;
+ * // Result: { email: string; address: { street?: string; city?: string } }
+ * ```
+ */
+type InferFormValue$1<T extends RegisteredFieldTypes[]> = InferFormValueWithDepth<T, 5>;
+
+/**
+ * Base configuration shared by all validators
+ */
+interface BaseValidatorConfig {
+    /** Conditional logic for when validator applies */
+    when?: ConditionalExpression;
+}
+/**
+ * Built-in validator configuration (required, email, min, max, etc.)
+ */
+interface BuiltInValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
+    /** Static value for the validator (e.g., min value, pattern) */
+    value?: number | string | RegExp;
+    /** Dynamic value expression that evaluates to validator parameter */
+    expression?: string;
+}
+/**
+ * Custom validator configuration using Angular's public FieldContext API
+ * Returns ValidationError | ValidationError[] | null synchronously
+ *
+ * Supports two patterns:
+ * 1. Function-based: { type: 'custom', functionName: 'myValidator' }
+ * 2. Expression-based: { type: 'custom', expression: 'fieldValue === formValue.password', kind: 'passwordMismatch' }
+ */
+interface CustomValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'custom';
+    /** Name of registered validator function (function-based pattern) */
+    functionName?: string;
+    /** Optional parameters to pass to validator function */
+    params?: Record<string, unknown>;
+    /** JavaScript expression to evaluate (expression-based pattern) */
+    expression?: string;
+    /** Error kind for expression-based validators - links to validationMessages */
+    kind?: string;
+    /**
+     * Parameters to include in error object for message interpolation (expression-based pattern)
+     * Map of parameter names to expressions that will be evaluated in the same context as the validation expression
+     *
+     * @example
+     * errorParams: {
+     *   minValue: 'formValue.minValue',
+     *   maxValue: 'formValue.maxValue'
+     * }
+     * // Allows message template: "Value must be between {{minValue}} and {{maxValue}}"
+     */
+    errorParams?: Record<string, string>;
+}
+/**
+ * Async custom validator configuration using Angular's validateAsync API
+ * Returns Observable<ValidationError | ValidationError[] | null>
+ */
+interface AsyncValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'customAsync';
+    /** Name of registered async validator function */
+    functionName: string;
+    /** Optional parameters to pass to validator function */
+    params?: Record<string, unknown>;
+}
+/**
+ * HTTP validator configuration using Angular's validateHttp API
+ * Provides optimized HTTP validation with automatic request cancellation
+ */
+interface HttpValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'customHttp';
+    /** Name of registered HTTP validator configuration */
+    functionName: string;
+    /** Optional parameters to pass to HTTP validator */
+    params?: Record<string, unknown>;
+}
+/**
+ * Configuration for signal forms validator functions that can be serialized from API
+ * Discriminated union type for type-safe validator configuration
+ */
+type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | HttpValidatorConfig;
+
+/**
+ * Configuration for applying predefined schemas
+ */
+interface SchemaApplicationConfig {
+    /** Schema application type */
+    type: 'apply' | 'applyWhen' | 'applyWhenValue' | 'applyEach';
+    /** Schema identifier or inline schema definition */
+    schema: string | SchemaDefinition;
+    /** Condition for conditional application */
+    condition?: ConditionalExpression;
+    /** Type predicate for applyWhenValue */
+    typePredicate?: string;
+}
+/**
+ * Reusable schema definition that can be referenced by name
+ */
+interface SchemaDefinition {
+    /** Unique schema identifier */
+    name: string;
+    /** Schema description */
+    description?: string;
+    /** Field path pattern this schema applies to */
+    pathPattern?: string;
+    /** Validators to apply */
+    validators?: ValidatorConfig[];
+    /** Logic rules to apply */
+    logic?: LogicConfig[];
+    /** Nested schema applications */
+    subSchemas?: SchemaApplicationConfig[];
+}
+
+/**
+ * Custom validator function signature using Angular's public FieldContext API
+ *
+ * Takes FieldContext (full Angular context) and optional params, returns validation error(s) or null.
+ * Provides access to field state, form hierarchy, and other fields for validation logic.
+ *
+ * **Use FieldContext public APIs to access:**
+ * - Current field value: `ctx.value()`
+ * - Field state: `ctx.state` (errors, touched, dirty, etc.)
+ * - Other field values: `ctx.valueOf(path)` where path is a FieldPath
+ * - Other field states: `ctx.stateOf(path)`
+ * - Other fields: `ctx.fieldOf(path)`
+ * - Current field tree: `ctx.field`
+ *
+ * **Return Types:**
+ * - Single error: `{ kind: 'errorKind' }` for field-level validation
+ * - Multiple errors: `[{ kind: 'error1' }, { kind: 'error2' }]` for cross-field validation
+ * - No error: `null` when validation passes
+ *
+ * **Best Practice - Return Only Error Kind:**
+ * Validators should focus on validation logic, not presentation.
+ * Return just the error `kind` and configure messages at field level for i18n support.
+ *
+ * @example Single Field Validation
+ * ```typescript
+ * const noSpaces: CustomValidator<string> = (ctx) => {
+ *   const value = ctx.value();
+ *   if (typeof value === 'string' && value.includes(' ')) {
+ *     return { kind: 'noSpaces' };
+ *   }
+ *   return null;
+ * };
+ *
+ * // Field configuration
+ * {
+ *   key: 'username',
+ *   validators: [{ type: 'custom', functionName: 'noSpaces' }],
+ *   validationMessages: {
+ *     noSpaces: 'Spaces are not allowed'
+ *   }
+ * }
+ * ```
+ *
+ * @example Cross-Field Validation with valueOf()
+ * ```typescript
+ * // Compare two fields using public API
+ * const lessThan: CustomValidator<number> = (ctx, params) => {
+ *   const value = ctx.value();
+ *   const compareToPath = params?.field as string;
+ *
+ *   // Use valueOf() to access other field - public API!
+ *   const otherValue = ctx.valueOf(compareToPath as any);
+ *
+ *   if (otherValue !== undefined && value >= otherValue) {
+ *     return { kind: 'notLessThan' };
+ *   }
+ *   return null;
+ * };
+ * ```
+ *
+ * @example Multiple Errors (Cross-Field Validation)
+ * ```typescript
+ * const validateDateRange: CustomValidator = (ctx) => {
+ *   const errors: ValidationError[] = [];
+ *
+ *   const startDate = ctx.valueOf('startDate' as any);
+ *   const endDate = ctx.valueOf('endDate' as any);
+ *
+ *   if (!startDate) errors.push({ kind: 'startDateRequired' });
+ *   if (!endDate) errors.push({ kind: 'endDateRequired' });
+ *   if (startDate && endDate && startDate > endDate) {
+ *     errors.push({ kind: 'invalidDateRange' });
+ *   }
+ *
+ *   return errors.length > 0 ? errors : null;
+ * };
+ * ```
+ *
+ * **Message Resolution Priority:**
+ * 1. Field-level `validationMessages[kind]` (highest priority - per-field customization)
+ * 2. Form-level `defaultValidationMessages[kind]` (fallback for common messages)
+ * 3. **No message configured = Warning logged + error NOT displayed**
+ *
+ * **Important:** Validator-returned messages are NOT used. All messages MUST be explicitly configured.
+ *
+ * @template TValue The type of value stored in the field being validated
+ */
+type CustomValidator<TValue = unknown> = (ctx: FieldContext<TValue>, params?: Record<string, unknown>) => ValidationError$1 | ValidationError$1[] | null;
+/**
+ * Async custom validator configuration using Angular's resource-based API
+ *
+ * Angular's validateAsync uses the resource API for async validation,
+ * which provides better integration with Signal Forms lifecycle management.
+ *
+ * **Structure:**
+ * - `params`: Function that computes params from field context
+ * - `factory`: Function that creates a ResourceRef from params signal
+ * - `onSuccess`: Maps successful resource result to validation errors
+ * - `onError`: Optional handler for resource errors (network failures, etc.)
+ *
+ * **Use Cases:**
+ * - Database lookups via services with resource API
+ * - Complex async business logic with Angular resources
+ * - Any async operation using Angular's resource pattern
+ *
+ * **Note:** For HTTP validation, prefer `HttpCustomValidator` which provides
+ * a simpler API specifically designed for HTTP requests.
+ *
+ * @example Database Lookup with Resource
+ * ```typescript
+ * const checkUsernameAvailable: AsyncCustomValidator<string> = {
+ *   params: (ctx) => ({ username: ctx.value() }),
+ *   factory: (params) => {
+ *     const injector = inject(Injector);
+ *     return resource({
+ *       request: () => params(),
+ *       loader: ({ request }) => {
+ *         if (!request?.username) return null;
+ *         const service = injector.get(UserService);
+ *         return firstValueFrom(service.checkAvailability(request.username));
+ *       }
+ *     });
+ *   },
+ *   onSuccess: (result, ctx) => {
+ *     if (!result) return null;
+ *     return result.available ? null : { kind: 'usernameTaken' };
+ *   },
+ *   onError: (error, ctx) => {
+ *     console.error('Availability check failed:', error);
+ *     return null; // Don't block form on network errors
+ *   }
+ * };
+ * ```
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TParams The type of params passed to the resource
+ * @template TResult The type of result returned by the resource
+ */
+interface AsyncCustomValidator<TValue = unknown, TParams = unknown, TResult = unknown> {
+    /**
+     * Function that receives field context and returns resource params.
+     * Params will be tracked as a signal and trigger resource reload when changed.
+     */
+    readonly params: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => TParams;
+    /**
+     * Function that creates a ResourceRef from the params signal.
+     * The resource will be automatically managed by Angular's lifecycle.
+     */
+    readonly factory: (params: Signal<TParams | undefined>) => ResourceRef<TResult | undefined>;
+    /**
+     * Optional function to map successful resource result to validation errors.
+     * Return null if validation passes, or ValidationError/ValidationError[] if validation fails.
+     */
+    readonly onSuccess?: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
+    /**
+     * Optional error handler for resource errors (network failures, etc.).
+     * Return null to ignore the error, or ValidationError to display it to the user.
+     */
+    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
+}
+/**
+ * HTTP request configuration for validateHttp API
+ */
+interface HttpResourceRequest {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: any;
+    headers?: Record<string, string | string[]>;
+}
+/**
+ * HTTP-based validator configuration for Angular's validateHttp API
+ *
+ * Angular's validateHttp provides optimized HTTP validation with automatic
+ * request cancellation and integration with the resource API.
+ *
+ * **Benefits:**
+ * - Automatic request cancellation when field value changes
+ * - Built-in integration with Angular's resource management
+ * - Simpler than AsyncCustomValidator for HTTP use cases
+ *
+ * **Structure:**
+ * - `request`: Function that returns URL string or HttpResourceRequest
+ * - `onSuccess`: REQUIRED - Maps HTTP response to validation errors (inverted logic!)
+ * - `onError`: Optional handler for HTTP errors (network failures, 4xx/5xx)
+ *
+ * **Important:** `onSuccess` uses inverted logic - it maps SUCCESSFUL HTTP responses
+ * to validation errors. For example, if the API returns `{ available: false }`,
+ * your `onSuccess` should return `{ kind: 'usernameTaken' }`.
+ *
+ * @example Username Availability Check (GET)
+ * ```typescript
+ * const checkUsername: HttpCustomValidator<string> = {
+ *   request: (ctx) => {
+ *     const username = ctx.value();
+ *     if (!username) return undefined; // Skip validation if empty
+ *     return `/api/users/check-username?username=${encodeURIComponent(username)}`;
+ *   },
+ *   onSuccess: (response, ctx) => {
+ *     // Inverted logic: successful response may indicate validation failure
+ *     return response.available ? null : { kind: 'usernameTaken' };
+ *   },
+ *   onError: (error, ctx) => {
+ *     console.error('Availability check failed:', error);
+ *     return null; // Don't block form on network errors
+ *   }
+ * };
+ * ```
+ *
+ * @example Address Validation (POST with Body)
+ * ```typescript
+ * const validateAddress: HttpCustomValidator = {
+ *   request: (ctx) => {
+ *     const zipCode = ctx.value();
+ *     if (!zipCode) return undefined;
+ *
+ *     return {
+ *       url: '/api/validate-address',
+ *       method: 'POST',
+ *       body: {
+ *         street: ctx.valueOf('street' as any),
+ *         city: ctx.valueOf('city' as any),
+ *         zipCode: zipCode
+ *       },
+ *       headers: { 'Content-Type': 'application/json' }
+ *     };
+ *   },
+ *   onSuccess: (response) => {
+ *     return response.valid ? null : { kind: 'invalidAddress' };
+ *   }
+ * };
+ * ```
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TResult The type of HTTP response
+ */
+interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
+    /**
+     * Function that returns the HTTP request configuration.
+     * Can return:
+     * - `undefined` to skip validation (e.g., if field is empty)
+     * - `string` for simple GET requests (just the URL)
+     * - `HttpResourceRequest` for full control (method, body, headers)
+     */
+    readonly request: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => string | HttpResourceRequest | undefined;
+    /**
+     * REQUIRED function to map successful HTTP response to validation errors.
+     *
+     * **Inverted Logic:** This is called on successful HTTP responses.
+     * Return null if validation passes, or ValidationError/ValidationError[] if validation fails.
+     *
+     * Example: API returns `{ available: false }` → return `{ kind: 'usernameTaken' }`
+     */
+    readonly onSuccess: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
+    /**
+     * Optional error handler for HTTP errors (network failures, 4xx/5xx status codes).
+     * Return null to ignore the error, or ValidationError to display it to the user.
+     *
+     * Common pattern: Log the error and return null to avoid blocking form submission
+     * on network issues.
+     */
+    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
+}
+
+interface EvaluationContext<TValue = unknown> {
+    /** Current field value */
+    fieldValue: TValue;
+    /** Complete form value */
+    formValue: Record<string, unknown>;
+    /** Field path for relative references */
+    fieldPath: string;
+    /** Custom evaluation functions */
+    customFunctions?: Record<string, (context: EvaluationContext) => unknown>;
+    /** Allow additional properties for flexible expression evaluation */
+    [key: string]: unknown;
+}
+
+/**
+ * Custom function signature for conditional expressions
+ *
+ * Custom functions are used for conditional logic in:
+ * - `when` conditions (field visibility, conditional validation)
+ * - `readonly` logic (dynamic readonly state)
+ * - `disabled` logic (dynamic disabled state)
+ * - Dynamic value calculations
+ *
+ * Unlike validators, custom functions:
+ * - Return any value (typically boolean for conditions, but could be strings, numbers, etc.)
+ * - Do NOT return ValidationError objects
+ * - Receive EvaluationContext (field values) not FieldContext (field state)
+ *
+ * @example
+ * ```typescript
+ * // Boolean condition function
+ * const isAdult: CustomFunction = (ctx) => {
+ *   return ctx.age >= 18;
+ * };
+ *
+ * // Used in field configuration:
+ * {
+ *   key: 'alcoholPreference',
+ *   type: 'select',
+ *   when: { function: 'isAdult' }  // Only show if isAdult returns true
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Calculation function
+ * const calculateDiscount: CustomFunction = (ctx) => {
+ *   const price = ctx.price || 0;
+ *   const isVip = ctx.isVip || false;
+ *   return isVip ? price * 0.8 : price * 0.9;
+ * };
+ * ```
+ */
+type CustomFunction = (context: EvaluationContext) => unknown;
+
+/**
+ * The result type for submission actions.
+ * Can be either a Promise or an Observable.
+ *
+ * For success: return `undefined`, `null`, `void`, or any non-TreeValidationResult value.
+ * For server errors: return `TreeValidationResult` (array of field errors).
+ */
+type SubmissionActionResult = Promise<TreeValidationResult> | Observable<TreeValidationResult | unknown>;
+/**
+ * Configuration for form submission handling.
+ *
+ * When provided, enables integration with Angular Signal Forms' native `submit()` function.
+ * The submission mechanism is **optional** - you can still handle submission manually
+ * via the `(submitted)` output if you prefer.
+ *
+ * Supports both Promise-based and Observable-based submission actions. When an Observable
+ * is returned, it will be automatically converted using `firstValueFrom`.
+ *
+ * @example
+ * ```typescript
+ * // Using Observable (recommended for HTTP calls)
+ * // Simply return the HTTP observable - no need to map the result
+ * const config: FormConfig = {
+ *   fields: [...],
+ *   submission: {
+ *     action: (form) => this.http.post('/api/submit', form().value())
+ *   }
+ * };
+ *
+ * // With error handling for server validation errors
+ * const config: FormConfig = {
+ *   fields: [...],
+ *   submission: {
+ *     action: (form) => {
+ *       return this.http.post('/api/submit', form().value()).pipe(
+ *         catchError((error) => {
+ *           if (error.error?.code === 'EMAIL_EXISTS') {
+ *             return of([{ field: form.email, error: { kind: 'server', message: 'Email already exists' }}]);
+ *           }
+ *           throw error;
+ *         })
+ *       );
+ *     }
+ *   }
+ * };
+ *
+ * // Using Promise (also supported)
+ * const config: FormConfig = {
+ *   fields: [...],
+ *   submission: {
+ *     action: async (form) => {
+ *       const value = form().value();
+ *       try {
+ *         await this.api.submit(value);
+ *         return undefined;
+ *       } catch (error) {
+ *         if (error.code === 'EMAIL_EXISTS') {
+ *           return [{ field: form.email, error: { kind: 'server', message: 'Email already exists' }}];
+ *         }
+ *         throw error;
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * @typeParam TValue - The form value type
+ *
+ * @public
+ * @experimental
+ */
+interface SubmissionConfig<TValue = unknown> {
+    /**
+     * Action called when the form is submitted.
+     *
+     * This function receives the form's `FieldTree` and should return either a Promise or
+     * an Observable. For Observable returns, it will be automatically converted using `firstValueFrom`.
+     *
+     * **Return values:**
+     * - For success: return `undefined`, `null`, or simply let the Observable complete (the emitted value is ignored unless it's a TreeValidationResult)
+     * - For server errors: return `TreeValidationResult` (array of field/error pairs)
+     *
+     * **Observable support:** You can return an HttpClient observable directly without mapping the result.
+     * The form will treat Observable completion as success. Only return `TreeValidationResult` if you need
+     * to report server-side validation errors.
+     *
+     * Server errors returned will be automatically applied to the corresponding form fields.
+     *
+     * While this action is executing, `form().submitting()` will be `true`, enabling
+     * automatic button disabling and loading states.
+     *
+     * @param form - The form's FieldTree instance
+     * @returns Promise or Observable - for errors, return TreeValidationResult
+     *
+     * @example
+     * ```typescript
+     * // Simple - just return the HTTP observable
+     * action: (form) => this.http.post('/api/register', form().value())
+     *
+     * // With server error handling
+     * action: (form) => {
+     *   return this.http.post('/api/register', form().value()).pipe(
+     *     catchError((error) => {
+     *       if (error.status === 409) {
+     *         return of([{
+     *           field: form.email,
+     *           error: { kind: 'server', message: 'Email already exists' }
+     *         }]);
+     *       }
+     *       throw error;
+     *     })
+     *   );
+     * }
+     *
+     * // Promise-based alternative
+     * action: async (form) => {
+     *   await fetch('/api/register', {
+     *     method: 'POST',
+     *     body: JSON.stringify(form().value())
+     *   });
+     *   // Return undefined for success, or TreeValidationResult for errors
+     * }
+     * ```
+     */
+    action: (form: FieldTree<TValue>) => SubmissionActionResult;
+}
+
+/**
+ * Configuration interface for defining dynamic form structure and behavior.
+ *
+ * This interface defines the complete form schema including field definitions,
+ * validation rules, conditional logic, and submission handling using Angular's
+ * signal-based reactive forms.
+ *
+ * @example
+ * ```typescript
+ * const formConfig: FormConfig = {
+ *   fields: [
+ *     { type: 'input', key: 'email', value: '', label: 'Email', required: true, email: true },
+ *     { type: 'group', key: 'address', label: 'Address', fields: [
+ *       { type: 'input', key: 'street', value: '', label: 'Street' },
+ *       { type: 'input', key: 'city', value: '', label: 'City' }
+ *     ]},
+ *     { type: 'button', key: 'submit', label: 'Submit', buttonType: 'submit' }
+ *   ],
+ *   schemas: [
+ *     { name: 'emailSchema', schema: { email: validators.email } }
+ *   ]
+ * };
+ * ```
+ *
+ * @typeParam TFields - Array of registered field types available for this form
+ * @typeParam TValue - The strongly-typed interface for form values
+ *
+ * @public
+ */
+interface FormConfig<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields>> {
+    /**
+     * Array of field definitions that define the form structure.
+     *
+     * Fields are rendered in the order they appear in this array.
+     * Supports nested groups and conditional field visibility.
+     *
+     * @example
+     * ```typescript
+     * fields: [
+     *   { type: 'input', key: 'firstName', label: 'First Name' },
+     *   { type: 'group', key: 'address', label: 'Address', fields: [
+     *     { type: 'input', key: 'street', label: 'Street' }
+     *   ]}
+     * ]
+     * ```
+     */
+    fields: TFields;
+    /**
+     * Optional form-level validation schema.
+     *
+     * Provides additional validation beyond field-level validation.
+     * Useful for cross-field validation rules.
+     *
+     * @example
+     * ```typescript
+     * schema: {
+     *   passwordConfirm: validators.equals('password')
+     * }
+     * ```
+     */
+    schema?: Schema<TValue>;
+    /**
+     * Global form configuration options.
+     *
+     * Controls form-wide behavior like validation timing and disabled state.
+     *
+     * @value {}
+     */
+    options?: FormOptions;
+    /**
+     * Global schemas available to all fields.
+     *
+     * Reusable validation schemas that can be referenced by field definitions.
+     * Promotes consistency and reduces duplication.
+     *
+     * @example
+     * ```typescript
+     * schemas: [
+     *   { name: 'addressSchema', schema: {
+     *     street: validators.required,
+     *     zipCode: validators.pattern(/^\d{5}$/)
+     *   }}
+     * ]
+     * ```
+     */
+    schemas?: SchemaDefinition[];
+    /**
+     * Form-level validation messages that act as fallback for field-level messages.
+     *
+     * These messages are used when a field has validation errors but no
+     * field-level `validationMessages` are defined for that specific error.
+     * This allows you to define common validation messages once at the form level
+     * instead of repeating them for each field.
+     *
+     * @example
+     * ```typescript
+     * defaultValidationMessages: {
+     *   required: 'This field is required',
+     *   email: 'Please enter a valid email address',
+     *   minLength: 'Must be at least {{requiredLength}} characters'
+     * }
+     * ```
+     */
+    defaultValidationMessages?: ValidationMessages;
+    /**
+     * Signal forms adapter configuration.
+     */
+    customFnConfig?: CustomFnConfig;
+    /**
+     * Form submission configuration.
+     *
+     * When provided, enables integration with Angular Signal Forms' native `submit()` function.
+     * The submission mechanism is **optional** - you can still handle submission manually
+     * via the `(submitted)` output if you prefer.
+     *
+     * While the submission action is executing, `form().submitting()` will be `true`,
+     * which automatically disables submit buttons (unless configured otherwise).
+     *
+     * Server errors returned from the action will be automatically applied to the
+     * corresponding form fields.
+     *
+     * @example
+     * ```typescript
+     * const config: FormConfig = {
+     *   fields: [...],
+     *   submission: {
+     *     action: async (form) => {
+     *       const value = form().value();
+     *       try {
+     *         await this.api.submit(value);
+     *         return undefined;
+     *       } catch (error) {
+     *         return [{ field: form.email, error: { kind: 'server', message: 'Email exists' }}];
+     *       }
+     *     }
+     *   }
+     * };
+     * ```
+     */
+    submission?: SubmissionConfig<TValue>;
+}
+/**
+ * Signal forms adapter configuration for advanced form behavior.
+ *
+ * Provides configuration options for signal forms integration including
+ * legacy migration, custom functions, and custom validators.
+ *
+ * @example
+ * ```typescript
+ * customFnConfig: {
+ *   customFunctions: {
+ *     isAdult: (context) => context.age >= 18,
+ *     formatCurrency: (context) => new Intl.NumberFormat('en-US', {
+ *       style: 'currency',
+ *       currency: 'USD'
+ *     }).format(context.value)
+ *   },
+ *   simpleValidators: {
+ *     noSpaces: (value) => {
+ *       return typeof value === 'string' && value.includes(' ')
+ *         ? { kind: 'noSpaces', message: 'Spaces not allowed' }
+ *         : null;
+ *     }
+ *   },
+ *   contextValidators: {
+ *     lessThanField: (ctx, params) => {
+ *       const value = ctx.value();
+ *       const otherField = params?.field as string;
+ *       const otherValue = ctx.root()[otherField]?.value();
+ *       if (otherValue !== undefined && value >= otherValue) {
+ *         return { kind: 'notLessThan', message: `Must be less than ${otherField}` };
+ *       }
+ *       return null;
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+interface CustomFnConfig {
+    /**
+     * Custom evaluation functions for conditional expressions.
+     *
+     * Used for: when/readonly/disabled logic
+     * Return type: any value (typically boolean)
+     *
+     * @example
+     * ```typescript
+     * customFunctions: {
+     *   isAdult: (context) => context.age >= 18,
+     *   calculateAge: (context) => {
+     *     const birthDate = new Date(context.birthDate);
+     *     return new Date().getFullYear() - birthDate.getFullYear();
+     *   }
+     * }
+     * ```
+     */
+    customFunctions?: Record<string, CustomFunction>;
+    /**
+     * Custom validators using Angular's public FieldContext API
+     *
+     * (ctx, params?) => ValidationError | ValidationError[] | null
+     *
+     * Validators receive FieldContext which provides access to:
+     * - Current field value: `ctx.value()`
+     * - Field state: `ctx.state` (errors, touched, dirty, etc.)
+     * - Other field values: `ctx.valueOf(path)` - public API!
+     * - Other field states: `ctx.stateOf(path)`
+     * - Parameters from JSON configuration
+     *
+     * **Return Types:**
+     * - Single error: `{ kind: 'errorKind' }` for field-level validation
+     * - Multiple errors: `[{ kind: 'error1' }, { kind: 'error2' }]` for cross-field validation
+     * - No error: `null` when validation passes
+     *
+     * @example Single Field Validation
+     * ```typescript
+     * validators: {
+     *   noSpaces: (ctx) => {
+     *     const value = ctx.value();
+     *     if (typeof value === 'string' && value.includes(' ')) {
+     *       return { kind: 'noSpaces' };
+     *     }
+     *     return null;
+     *   }
+     * }
+     * ```
+     *
+     * @example Cross-Field Validation (Public API)
+     * ```typescript
+     * validators: {
+     *   lessThan: (ctx, params) => {
+     *     const value = ctx.value();
+     *     const compareToPath = params?.field as string;
+     *
+     *     // Use valueOf() to access other field - public API!
+     *     const otherValue = ctx.valueOf(compareToPath as any);
+     *
+     *     if (otherValue !== undefined && value >= otherValue) {
+     *       return { kind: 'notLessThan' };
+     *     }
+     *     return null;
+     *   }
+     * }
+     * ```
+     *
+     * @example Multiple Errors
+     * ```typescript
+     * validators: {
+     *   validateDateRange: (ctx) => {
+     *     const errors: ValidationError[] = [];
+     *     const startDate = ctx.valueOf('startDate' as any);
+     *     const endDate = ctx.valueOf('endDate' as any);
+     *
+     *     if (!startDate) errors.push({ kind: 'startDateRequired' });
+     *     if (!endDate) errors.push({ kind: 'endDateRequired' });
+     *     if (startDate && endDate && startDate > endDate) {
+     *       errors.push({ kind: 'invalidDateRange' });
+     *     }
+     *
+     *     return errors.length > 0 ? errors : null;
+     *   }
+     * }
+     * ```
+     */
+    validators?: Record<string, CustomValidator>;
+    /**
+     * Async custom validators using Angular's resource-based validateAsync() API
+     *
+     * Angular's validateAsync uses the resource API for async validation.
+     * Validators must provide params, factory, onSuccess, and optional onError callbacks.
+     *
+     * **Structure:**
+     * - `params`: Function that computes params from field context
+     * - `factory`: Function that creates ResourceRef from params signal
+     * - `onSuccess`: Maps resource result to validation errors
+     * - `onError`: Optional handler for resource errors
+     *
+     * **Use Cases:**
+     * - Database lookups via services with resource API
+     * - Complex async business logic with Angular resources
+     *
+     * **Note:** For HTTP validation, prefer `httpValidators` which provides
+     * a simpler API specifically designed for HTTP requests.
+     *
+     * @example Database Lookup with Resource
+     * ```typescript
+     * asyncValidators: {
+     *   checkUsernameAvailable: {
+     *     params: (ctx) => ({ username: ctx.value() }),
+     *     factory: (params) => {
+     *       const injector = inject(Injector);
+     *       return resource({
+     *         request: () => params(),
+     *         loader: ({ request }) => {
+     *           if (!request?.username) return null;
+     *           const service = injector.get(UserService);
+     *           return firstValueFrom(service.checkAvailability(request.username));
+     *         }
+     *       });
+     *     },
+     *     onSuccess: (result, ctx) => {
+     *       if (!result) return null;
+     *       return result.available ? null : { kind: 'usernameTaken' };
+     *     },
+     *     onError: (error, ctx) => {
+     *       console.error('Availability check failed:', error);
+     *       return null; // Don't block form on network errors
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    asyncValidators?: Record<string, AsyncCustomValidator>;
+    /**
+     * HTTP validators using Angular's validateHttp() API
+     *
+     * Angular's validateHttp provides HTTP validation with automatic request
+     * cancellation and integration with the resource API.
+     *
+     * **Structure:**
+     * - `request`: Function that returns URL string or HttpResourceRequest
+     * - `onSuccess`: REQUIRED - Maps HTTP response to validation errors (inverted logic!)
+     * - `onError`: Optional handler for HTTP errors
+     *
+     * **Benefits:**
+     * - Automatic request cancellation when field value changes
+     * - Built-in integration with Angular's resource management
+     * - Simpler than asyncValidators for HTTP use cases
+     *
+     * **Important:** `onSuccess` uses inverted logic - it maps SUCCESSFUL HTTP responses
+     * to validation errors. For example, if the API returns `{ available: false }`,
+     * your `onSuccess` should return `{ kind: 'usernameTaken' }`.
+     *
+     * @example Username Availability Check (GET)
+     * ```typescript
+     * httpValidators: {
+     *   checkUsername: {
+     *     request: (ctx) => {
+     *       const username = ctx.value();
+     *       if (!username) return undefined; // Skip validation if empty
+     *       return `/api/users/check-username?username=${encodeURIComponent(username)}`;
+     *     },
+     *     onSuccess: (response, ctx) => {
+     *       // Inverted logic: successful response may indicate validation failure
+     *       return response.available ? null : { kind: 'usernameTaken' };
+     *     },
+     *     onError: (error, ctx) => {
+     *       console.error('Availability check failed:', error);
+     *       return null; // Don't block form on network errors
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @example Address Validation (POST with Body)
+     * ```typescript
+     * httpValidators: {
+     *   validateAddress: {
+     *     request: (ctx) => {
+     *       const zipCode = ctx.value();
+     *       if (!zipCode) return undefined;
+     *
+     *       return {
+     *         url: '/api/validate-address',
+     *         method: 'POST',
+     *         body: {
+     *           street: ctx.valueOf('street' as any),
+     *           city: ctx.valueOf('city' as any),
+     *           zipCode: zipCode
+     *         },
+     *         headers: { 'Content-Type': 'application/json' }
+     *       };
+     *     },
+     *     onSuccess: (response) => {
+     *       return response.valid ? null : { kind: 'invalidAddress' };
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    httpValidators?: Record<string, HttpCustomValidator>;
+}
+/**
+ * Global form configuration options.
+ *
+ * Controls form-wide behavior including disabled state
+ * and button behavior configuration.
+ *
+ * @example
+ * ```typescript
+ * options: {
+ *   disabled: false,
+ *   submitButton: { disableWhenInvalid: true }
+ * }
+ * ```
+ *
+ * @public
+ */
+interface FormOptions {
+    /**
+     * Disable the entire form.
+     *
+     * When enabled, all form fields become read-only and cannot
+     * be modified by user interaction.
+     *
+     * @value false
+     */
+    disabled?: boolean;
+    /**
+     * Default disabled behavior for submit buttons.
+     *
+     * Controls when submit buttons are automatically disabled.
+     * Can be overridden per-button via the `logic` array on individual button fields.
+     *
+     * @example
+     * ```typescript
+     * options: {
+     *   submitButton: {
+     *     disableWhenInvalid: true,      // Disable when form is invalid
+     *     disableWhileSubmitting: true,  // Disable during submission
+     *   }
+     * }
+     * ```
+     */
+    submitButton?: SubmitButtonOptions;
+    /**
+     * Default disabled behavior for next page buttons.
+     *
+     * Controls when next page buttons are automatically disabled in paged forms.
+     * Can be overridden per-button via the `logic` array on individual button fields.
+     *
+     * @example
+     * ```typescript
+     * options: {
+     *   nextButton: {
+     *     disableWhenPageInvalid: true,  // Disable when current page is invalid
+     *     disableWhileSubmitting: true,  // Disable during submission
+     *   }
+     * }
+     * ```
+     */
+    nextButton?: NextButtonOptions;
+}
+/**
+ * Options for controlling submit button disabled behavior.
+ *
+ * @public
+ */
+interface SubmitButtonOptions {
+    /**
+     * Disable submit button when the form is invalid.
+     *
+     * @default true
+     */
+    disableWhenInvalid?: boolean;
+    /**
+     * Disable submit button while the form is submitting.
+     *
+     * Requires `submission.action` to be configured for automatic detection.
+     *
+     * @default true
+     */
+    disableWhileSubmitting?: boolean;
+}
+/**
+ * Options for controlling next page button disabled behavior.
+ *
+ * @public
+ */
+interface NextButtonOptions {
+    /**
+     * Disable next button when the current page has invalid fields.
+     *
+     * @default true
+     */
+    disableWhenPageInvalid?: boolean;
+    /**
+     * Disable next button while the form is submitting.
+     *
+     * @default true
+     */
+    disableWhileSubmitting?: boolean;
+}
+
+/**
+ * Field signal context - the "nervous system" of the dynamic form.
+ * Provided via FIELD_SIGNAL_CONTEXT injection token.
+ *
+ * Gives mappers and components access to form state, values, and configuration.
+ * Container fields (Group, Array) create scoped contexts with nested forms.
+ */
+interface FieldSignalContext<TModel = unknown> {
+    injector: Injector;
+    value: WritableSignal<Partial<TModel> | undefined>;
+    defaultValues: () => TModel;
+    form: ReturnType<typeof form<TModel>>;
+    defaultValidationMessages?: ValidationMessages;
+    /** Form-level options used by button mappers to determine disabled state defaults. */
+    formOptions?: FormOptions;
+    /** Current page validity signal for paged forms. Used by next button to determine disabled state. */
+    currentPageValid?: Signal<boolean>;
+}
+/**
+ * Array context for fields rendered within arrays.
+ * Provides position and parent array information for components inside array fields.
+ */
+interface ArrayContext {
+    /** The key of the parent array field. */
+    arrayKey: string;
+    /**
+     * The index of this item within the array.
+     * Uses linkedSignal to automatically update when items are added/removed,
+     * allowing index-dependent logic to react without component recreation.
+     */
+    index: Signal<number>;
+    /** The current form value for token resolution. */
+    formValue: unknown;
+    /** The array field definition. */
+    field: FieldDef<unknown>;
+}
+/**
+ * Mapper function that converts a field definition to component inputs.
+ *
+ * Mappers run within an injection context and can inject FIELD_SIGNAL_CONTEXT.
+ * Returns a Signal to enable reactive updates when dependencies change.
+ */
+type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string, unknown>>;
+
+/**
+ * Defines how a field type handles form values and data collection.
+ *
+ * - 'include': Field contributes to form values (default for input fields)
+ * - 'exclude': Field is excluded from form values (for display/layout fields)
+ * - 'flatten': Field's children are flattened to parent level (for container fields)
+ */
+type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
+/**
+ * Configuration interface for registering custom field types.
+ *
+ * Defines how a field type should be handled by the dynamic form system,
+ * including its component loading strategy and field-to-component mapping logic.
+ * Supports both eager-loaded and lazy-loaded components.
+ *
+ * @typeParam T - The field definition type this field type handles
+ *
+ * @example
+ * ```typescript
+ * const CustomInputType: FieldTypeDefinition<InputFieldDef> = {
+ *   name: 'custom-input',
+ *   loadComponent: () => import('./custom-input.component').then(m => m.CustomInputComponent),
+ *   mapper: customInputMapper
+ * };
+ *
+ * // Register with providers
+ * provideDynamicForm(CustomInputType)
+ * ```
+ */
+interface FieldTypeDefinition<T extends FieldDef<any> = any> {
+    /** Unique identifier for the field type */
+    name: string;
+    /** Field definition type marker (internal use) */
+    _fieldDef?: T;
+    /** Function to load the component (supports lazy loading) */
+    loadComponent?: () => Promise<any>;
+    /** Mapper function that converts field definition to component bindings */
+    mapper: MapperFn<T>;
+    /** How this field type handles form values and data collection (defaults to 'include') */
+    valueHandling?: ValueHandlingMode;
+}
+/**
+ * Injection token for the global field type registry.
+ *
+ * Provides access to the map of registered field types throughout the application.
+ * The registry is populated by the provideDynamicForm function and used by
+ * field rendering components to resolve field types to their implementations.
+ *
+ * @example
+ * ```typescript
+ * constructor(@Inject(FIELD_REGISTRY) private registry: Map<string, FieldTypeDefinition>) {
+ *   const inputType = registry.get('input');
+ * }
+ * ```
+ */
+declare const FIELD_REGISTRY: InjectionToken<Map<string, FieldTypeDefinition<any>>>;
+/**
+ * Gets the value handling mode for a specific field type from the registry.
+ *
+ * @param fieldType - The field type identifier
+ * @param registry - The field type registry
+ * @returns The value handling mode ('include' is the default if not specified)
+ */
+declare function getFieldValueHandling(fieldType: string, registry: Map<string, FieldTypeDefinition>): ValueHandlingMode;
+
+/**
+ * Resolved field ready for rendering with ngComponentOutlet.
+ */
+interface ResolvedField {
+    key: string;
+    component: Type<unknown>;
+    injector: Injector;
+    inputs: Signal<Record<string, unknown>>;
+}
+
+/**
+ * Form mode enumeration distinguishing between paged and non-paged forms
+ */
+type FormMode = 'paged' | 'non-paged';
+/**
+ * Result of form mode detection with validation details
+ */
+interface FormModeDetectionResult {
+    /** The detected form mode */
+    mode: FormMode;
+    /** Whether the form configuration is valid for the detected mode */
+    isValid: boolean;
+    /** Array of validation errors if form is invalid */
+    errors: string[];
+}
+
+/**
+ * Type guard to check if a field is a container field (page, row, group, or array)
+ * Container fields have a 'fields' property and don't contribute values directly.
+ * This overload works with RegisteredFieldTypes for full type narrowing.
+ */
+declare function isContainerField(field: RegisteredFieldTypes): field is ContainerFieldTypes;
+/**
+ * Type guard to check if a field is a container field (page, row, group, or array).
+ * This overload works with any FieldDef for looser type checking.
+ */
+declare function isContainerField(field: FieldDef<unknown>): boolean;
+/**
+ * Type guard to check if a field is a leaf field (value or display field)
+ * Leaf fields don't have children and either contribute values or display content
+ */
+declare function isLeafField(field: RegisteredFieldTypes): field is LeafFieldTypes;
+/**
+ * Type guard to check if a field has a value property (value-bearing field)
+ * These fields contribute to the form value output
+ * Note: Using `unknown` in the Extract condition to match any value type
+ */
+declare function isValueBearingField(field: RegisteredFieldTypes): field is Extract<RegisteredFieldTypes, {
+    value: unknown;
+}>;
+/**
+ * Type guard to check if a field is excluded from form values (display-only field)
+ * Currently this includes text fields and any other fields without a value property
+ */
+declare function isDisplayOnlyField(field: RegisteredFieldTypes): boolean;
+
+/**
+ * Helper types for creating type-safe field configurations with proper nesting constraints
+ */
+
+/**
+ * Type helper for accessing nested field paths safely
+ * This allows accessing child paths while maintaining some type safety
+ */
+type FieldPathAccess<TValue> = {
+    [K in keyof TValue]: SchemaPath<TValue[K]> | SchemaPathTree<TValue[K]>;
+};
+
+/**
+ * Base interface for all form events in the dynamic form system.
+ *
+ * All form events must implement this interface to be compatible with
+ * the event bus system. The type property is used for event filtering
+ * and type-safe subscriptions.
+ *
+ * @example
+ * ```typescript
+ * export class SubmitEvent implements FormEvent {
+ *   readonly type = 'submit';
+ * }
+ *
+ * export class ValidationErrorEvent implements FormEvent {
+ *   readonly type = 'validation-error';
+ *   constructor(public errors: ValidationErrors) {}
+ * }
+ * ```
+ */
+interface FormEvent {
+    /** Unique identifier for the event type used for filtering and subscriptions */
+    readonly type: string;
+}
+/**
+ * Constructor type for form event classes.
+ *
+ * Defines the shape of event class constructors that can be used with
+ * the event bus dispatch system. Supports both parameterless and
+ * parameterized event constructors.
+ *
+ * @typeParam T - The form event type being constructed
+ *
+ * @example
+ * ```typescript
+ * // Parameterless event constructor
+ * const SubmitEventCtor: FormEventConstructor<SubmitEvent> = SubmitEvent;
+ *
+ * // Parameterized event constructor
+ * const ErrorEventCtor: FormEventConstructor<ErrorEvent> = ErrorEvent;
+ * eventBus.dispatch(ErrorEventCtor);
+ * ```
+ */
+type FormEventConstructor<T extends FormEvent = FormEvent> = new (...args: any[]) => T;
+
+/**
+ * Event dispatched when the form should be cleared.
+ *
+ * This event instructs the dynamic form component to clear all field values,
+ * resetting them to empty/undefined state regardless of their default values.
+ *
+ * @example
+ * ```typescript
+ * // Dispatch from a button component
+ * eventBus.dispatch(FormClearEvent);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Listen for clear events
+ * eventBus.on<FormClearEvent>('form-clear').subscribe(() => {
+ *   console.log('Form was cleared');
+ * });
+ * ```
+ */
+declare class FormClearEvent implements FormEvent {
+    readonly type: "form-clear";
+}
+
+/**
+ * Event dispatched when the form should be reset to its default values.
+ *
+ * This event instructs the dynamic form component to restore all field values
+ * to their initial default values as defined in the form configuration.
+ *
+ * @example
+ * ```typescript
+ * // Dispatch from a button component
+ * eventBus.dispatch(FormResetEvent);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Listen for reset events
+ * eventBus.on<FormResetEvent>('form-reset').subscribe(() => {
+ *   console.log('Form was reset to defaults');
+ * });
+ * ```
+ */
+declare class FormResetEvent implements FormEvent {
+    readonly type: "form-reset";
+}
+
+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);
+}
+
+/**
+ * State interface for the page orchestrator
+ */
+interface PageOrchestratorState {
+    /** Current page index (0-based) */
+    currentPageIndex: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Whether the current page is the first page */
+    isFirstPage: boolean;
+    /** Whether the current page is the last page */
+    isLastPage: boolean;
+    /** Whether navigation is currently disabled */
+    navigationDisabled: boolean;
+}
+
+declare class PageNavigationStateChangeEvent implements FormEvent {
+    state: PageOrchestratorState;
+    type: "page-navigation-state-change";
+    constructor(state: PageOrchestratorState);
+}
+
+/**
+ * Dynamic form component that renders a complete form based on configuration.
+ *
+ * This is the main entry point for the dynamic form system. It handles form state management,
+ * validation, field rendering, and event coordination using Angular's signal-based reactive forms.
+ *
+ * @typeParam TFields - Array of registered field types available for this form
+ * @typeParam TModel - The strongly-typed interface for form values
+ *
+ * @example
+ *```html
+ * <form
+ *  [dynamic-form]="formConfig"
+ *  [(value)]="formData"
+ *  (submitted)="handleSubmit($event)"
+ *  (validityChange)="handleValidityChange($event)">
+ * </form>
+ * ```
+ */
+declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel = InferFormValue$1<TFields>> implements OnDestroy {
+    private readonly destroyRef;
+    private readonly fieldRegistry;
+    private readonly injector;
+    private readonly eventBus;
+    private readonly rootFormRegistry;
+    private readonly functionRegistry;
+    private readonly schemaRegistry;
+    /** Form configuration defining the structure, validation, and behavior. */
+    config: InputSignal<FormConfig<TFields>>;
+    /** Runtime form options that override config options when provided. */
+    formOptions: InputSignal<FormOptions | undefined>;
+    /** Form values for two-way data binding. */
+    value: _angular_core.ModelSignal<Partial<TModel> | undefined>;
+    private readonly memoizedFlattenFields;
+    private readonly memoizedFlattenFieldsForRendering;
+    private readonly memoizedKeyBy;
+    private readonly memoizedDefaultValues;
+    private readonly rawFieldRegistry;
+    readonly formModeDetection: Signal<FormModeDetectionResult>;
+    private readonly formSetup;
+    readonly pageFieldDefinitions: Signal<PageField<_ng_forge_dynamic_forms.PageAllowedChildren[]>[]>;
+    readonly effectiveFormOptions: Signal<{
+        disabled?: boolean;
+        submitButton?: _ng_forge_dynamic_forms.SubmitButtonOptions;
+        nextButton?: _ng_forge_dynamic_forms.NextButtonOptions;
+    }>;
+    readonly fieldSignalContext: Signal<FieldSignalContext<TModel>>;
+    private readonly fieldInjector;
+    readonly defaultValues: _angular_core.WritableSignal<TModel>;
+    private readonly entity;
+    readonly form: Signal<_angular_forms_signals.FieldTree<TModel, string | number>>;
+    private readonly componentId;
+    private readonly totalComponentsCount;
+    private readonly fieldsSource;
+    /** Collects errors from async field component loading for error boundary patterns. */
+    readonly fieldLoadingErrors: _angular_core.WritableSignal<{
+        fieldType: string;
+        fieldKey: string;
+        error: Error;
+    }[]>;
+    /** Current form values (reactive). */
+    readonly formValue: Signal<TModel | (TModel extends infer T ? T extends TModel ? T extends _angular_forms.AbstractControl<unknown, infer TValue extends unknown, any> ? TValue : never : never : never)>;
+    /** Whether the form is currently valid. */
+    readonly valid: Signal<boolean>;
+    /** Whether the form is currently invalid. */
+    readonly invalid: Signal<boolean>;
+    /** Whether any form field has been modified. */
+    readonly dirty: Signal<boolean>;
+    /** Whether any form field has been touched (blurred). */
+    readonly touched: Signal<boolean>;
+    /** Current validation errors from all fields. */
+    readonly errors: Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    /** Whether the form is disabled (from options or form state). */
+    readonly disabled: Signal<boolean>;
+    /** Whether the form is currently submitting. */
+    readonly submitting: Signal<boolean>;
+    /**
+     * Announcement message for screen readers.
+     * Updates when form submission fails due to validation errors.
+     */
+    readonly errorAnnouncement: _angular_core.WritableSignal<string>;
+    readonly initialized$: rxjs.Observable<boolean>;
+    /** Emits when form validity changes. */
+    readonly validityChange: _angular_core.OutputRef<boolean>;
+    /** Emits when form dirty state changes. */
+    readonly dirtyChange: _angular_core.OutputRef<boolean>;
+    /**
+     * Emits form values when submitted (via SubmitEvent).
+     * Note: Does not emit when `submission.action` is configured - use one or the other.
+     */
+    readonly submitted: _angular_core.OutputRef<Partial<TModel> | undefined>;
+    /** Emits when form is reset to default values. */
+    readonly reset: _angular_core.OutputRef<FormResetEvent>;
+    /** Emits when form is cleared to empty state. */
+    readonly cleared: _angular_core.OutputRef<FormClearEvent>;
+    /** Emits all form events for custom event handling. */
+    readonly events: _angular_core.OutputRef<_ng_forge_dynamic_forms.FormEvent>;
+    /**
+     * Emits when all form components are initialized and ready for interaction.
+     * Useful for E2E testing to ensure the form is fully rendered before interaction.
+     */
+    readonly initialized: _angular_core.OutputRef<boolean>;
+    /** Emits when the current page changes in paged forms. */
+    readonly onPageChange: _angular_core.OutputRef<PageChangeEvent>;
+    /** Emits when page navigation state changes (canGoNext, canGoPrevious, etc.). */
+    readonly onPageNavigationStateChange: _angular_core.OutputRef<PageNavigationStateChangeEvent>;
+    protected readonly resolvedFields: Signal<ResolvedField[]>;
+    private readonly syncEntityToValue;
+    private readonly clearErrorsOnConfigChange;
+    private readonly emitPagedFormInitialized;
+    private readonly emitNonPagedFormInitialized;
+    private readonly handleFormReset;
+    private readonly handleFormClear;
+    /**
+     * Announces form validation errors to screen readers when submission is attempted
+     * on an invalid form.
+     */
+    private readonly handleErrorAnnouncement;
+    private readonly handleSubmission;
+    /**
+     * Handles native form submission triggered by:
+     * - Pressing Enter in an input field
+     * - Clicking a button with type="submit"
+     * - Programmatic form.submit() calls
+     *
+     * This method prevents the default form submission behavior (page reload)
+     * and dispatches a SubmitEvent through the EventBus for processing.
+     *
+     * @param event - The native submit event from the form element
+     */
+    protected onNativeSubmit(event: Event): void;
+    private registerValidatorsFromConfig;
+    private createFormSetupFromConfig;
+    private createEmptyFormSetup;
+    private onFormReset;
+    private onFormClear;
+    /**
+     * Counts the total number of validation errors across all fields.
+     * Used for screen reader announcements.
+     */
+    private countErrors;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicForm<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicForm<any, any>, "form[dynamic-form]", never, { "config": { "alias": "dynamic-form"; "required": true; "isSignal": true; }; "formOptions": { "alias": "formOptions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; "reset": "reset"; "cleared": "cleared"; "events": "events"; "initialized": "initialized"; "onPageChange": "onPageChange"; "onPageNavigationStateChange": "onPageNavigationStateChange"; }, never, never, true, never>;
+}
+
+/**
+ * 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
+ */
+type InferFormValue<TFieldDefs extends FieldDef<any>[]> = {
+    [K in TFieldDefs[number]['key']]: any;
+};
+/**
+ * Provider result with type inference
+ */
+type ProvideDynamicFormResult<T extends FieldTypeDefinition[]> = EnvironmentProviders & {
+    __fieldDefs?: FieldDefUnion<T>;
+    __formValue?: InferFormValue<FieldDefUnion<T>[]>;
+};
+/**
+ * Provider function to configure the dynamic form system with field types and options.
+ *
+ * This function creates environment providers that can be used at application or route level
+ * to register field types. It provides type-safe field registration with automatic type inference.
+ *
+ * @param fieldTypes - Custom field type definitions to register alongside built-in types
+ * @returns Environment providers for dependency injection with type inference
+ *
+ * @example
+ * ```typescript
+ * // Application-level setup
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDynamicForm(...withMaterialFields())
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Route-level setup
+ * const routes: Routes = [
+ *   {
+ *     path: 'form',
+ *     component: FormComponent,
+ *     providers: [provideDynamicForm(...withMaterialFields())]
+ *   }
+ * ];
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom field types with type inference
+ * import { CustomFieldType, AnotherFieldType } from './custom-fields';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideDynamicForm(CustomFieldType, AnotherFieldType)
+ *   ]
+ * };
+ * ```
+ *
+ * @typeParam T - Array of field type definitions for type inference
+ *
+ * @public
+ */
+declare function provideDynamicForm<const T extends FieldTypeDefinition[]>(...fieldTypes: T): ProvideDynamicFormResult<T>;
+/**
+ * Extract FieldDef types from provider result
+ */
+type ExtractFieldDefs<T> = T extends {
+    __fieldDefs?: infer F;
+} ? F : never;
+/**
+ * Extract form value type from provider result
+ */
+type ExtractFormValue<T> = T extends {
+    __formValue?: infer V;
+} ? V : never;
+
+/**
+ * Built-in field types provided by the dynamic form library.
+ *
+ * These core field types handle form structure and layout. They are automatically
+ * registered when using provideDynamicForm() and form the foundation for building
+ * complex form layouts with nested fields and multi-step flows.
+ *
+ * @example
+ * ```typescript
+ * // Row field for horizontal layout
+ * { type: 'row', fields: [
+ *   { type: 'input', key: 'firstName' },
+ *   { type: 'input', key: 'lastName' }
+ * ]}
+ *
+ * // Group field for nested form sections
+ * { type: 'group', key: 'address', fields: [
+ *   { type: 'input', key: 'street' },
+ *   { type: 'input', key: 'city' }
+ * ]}
+ *
+ * // Array field for array-based form sections
+ * { type: 'array', key: 'items', fields: [
+ *   { type: 'input', key: 'name' },
+ *   { type: 'input', key: 'quantity' }
+ * ]}
+ *
+ * // Page field for multi-step forms
+ * { type: 'page', key: 'step1', fields: [...] }
+ * ```
+ */
+declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
+
+interface FieldOption<T = unknown> {
+    label: DynamicText;
+    value: T;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+
+/**
+ * Injection token for providing field signal context to mappers and components.
+ *
+ * The field signal context is the "nervous system" of the dynamic form library,
+ * providing access to:
+ * - The form instance and structure
+ * - Current form values (as signals)
+ * - Default values
+ * - Validation messages
+ * - The injector for creating components
+ *
+ * This token is provided by the DynamicForm component and can be scoped
+ * for nested forms (Groups, Arrays) via child injectors.
+ *
+ * @example
+ * ```typescript
+ * // In a mapper function
+ * export function mapValueField(fieldDef: BaseValueField<any, any>): Binding[] {
+ *   const context = inject(FIELD_SIGNAL_CONTEXT);
+ *   const form = context.form();
+ *   // ... use context
+ * }
+ *
+ * // In a component
+ * export class MyFieldComponent {
+ *   private context = inject(FIELD_SIGNAL_CONTEXT);
+ * }
+ * ```
+ */
+declare const FIELD_SIGNAL_CONTEXT: InjectionToken<FieldSignalContext<unknown>>;
+/**
+ * Injection token for providing array context metadata to mappers and components.
+ *
+ * This token is optionally provided by ArrayFieldComponent when creating injectors
+ * for array items. It contains metadata about the array item's position and parent.
+ *
+ * Mappers can inject this token with {optional: true} to access array context:
+ *
+ * @example
+ * ```typescript
+ * // In a mapper function
+ * export function buttonMapper(fieldDef: FieldDef<any>): Binding[] {
+ *   const arrayContext = inject(ARRAY_CONTEXT, { optional: true });
+ *   if (arrayContext) {
+ *     // Use arrayContext.index, arrayContext.arrayKey, etc.
+ *   }
+ * }
+ * ```
+ */
+declare const ARRAY_CONTEXT: InjectionToken<ArrayContext>;
+
+/**
+ * Context for resolving button disabled state.
+ *
+ * @public
+ */
+interface ButtonLogicContext {
+    /** The form's FieldTree instance */
+    form: FieldTree<unknown>;
+    /** Form-level options */
+    formOptions?: FormOptions;
+    /** Field-level logic array (if provided) */
+    fieldLogic?: LogicConfig[];
+    /** Explicit disabled state from field definition */
+    explicitlyDisabled?: boolean;
+    /** Current page validity signal (for paged forms) */
+    currentPageValid?: Signal<boolean>;
+    /** Current form value for evaluating conditional expressions */
+    formValue?: unknown;
+}
+/**
+ * Resolves the disabled state for a submit button.
+ *
+ * The disabled state is determined by (in order of precedence):
+ * 1. Explicit `disabled: true` on the field definition
+ * 2. Field-level `logic` array (if present, overrides form-level defaults)
+ * 3. Form-level `options.submitButton` defaults
+ *
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
+ *
+ * @example
+ * ```typescript
+ * const disabled = resolveSubmitButtonDisabled({
+ *   form: formInstance,
+ *   formOptions: config.options,
+ *   fieldLogic: buttonField.logic,
+ *   explicitlyDisabled: buttonField.disabled,
+ * });
+ *
+ * // Use in template
+ * <button [disabled]="disabled()">Submit</button>
+ * ```
+ *
+ * @public
+ */
+declare function resolveSubmitButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+/**
+ * Resolves the disabled state for a next page button.
+ *
+ * The disabled state is determined by (in order of precedence):
+ * 1. Explicit `disabled: true` on the field definition
+ * 2. Field-level `logic` array (if present, overrides form-level defaults)
+ * 3. Form-level `options.nextButton` defaults
+ *
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
+ *
+ * @example
+ * ```typescript
+ * const disabled = resolveNextButtonDisabled({
+ *   form: formInstance,
+ *   formOptions: config.options,
+ *   fieldLogic: buttonField.logic,
+ *   explicitlyDisabled: buttonField.disabled,
+ *   currentPageValid: pageOrchestrator.currentPageValid,
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function resolveNextButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+
+interface FieldWithValidation {
+    readonly required?: boolean;
+    readonly email?: boolean;
+    readonly min?: number;
+    readonly max?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string | RegExp;
+    readonly validators?: ValidatorConfig[];
+    readonly validationMessages?: ValidationMessages;
+    readonly logic?: LogicConfig[];
+    readonly schemas?: SchemaApplicationConfig[];
+}
+
+/**
+ * Supported primitive value types for form fields.
+ * This type represents all possible value types that can be used in form fields.
+ */
+type ValueType = string | number | boolean | Date | object | unknown[];
+interface BaseValueField<TProps, TValue> extends FieldDef<TProps>, FieldWithValidation {
+    value?: TValue;
+    /**
+     * Placeholder text displayed when the field is empty.
+     * Supports static strings, Observables, and Signals for dynamic content.
+     */
+    placeholder?: DynamicText;
+    required?: boolean;
+}
+declare function isValueField<TProps>(field: FieldDef<TProps>): field is BaseValueField<TProps, ValueType>;
+type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'valueType' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'schemas';
+type ValueFieldComponent<T extends BaseValueField<any, unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
+
+interface BaseCheckedField<TProps> extends FieldDef<TProps>, FieldWithValidation {
+    value?: boolean;
+    /**
+     * Placeholder text displayed when the field is empty.
+     * Supports static strings, Observables, and Signals for dynamic content.
+     */
+    placeholder?: DynamicText;
+    required?: boolean;
+}
+declare function isCheckedField<TProps>(field: FieldDef<TProps>): field is BaseCheckedField<TProps>;
+type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation;
+type CheckedFieldComponent<T extends BaseCheckedField<any>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
+
+/**
+ * HTML input types supported by input fields
+ */
+type InputType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
+/**
+ * Props for input fields with optional inputType specification.
+ * This is a generic interface that can be extended by framework-specific implementations.
+ */
+interface InputProps<T extends InputType = InputType> {
+    /**
+     * The HTML input type. Determines the value type:
+     * - 'number': value will be number
+     * - 'text', 'email', 'password', 'tel', 'url': value will be string
+     */
+    type?: T;
+    placeholder?: DynamicText;
+}
+/**
+ * Number input field with strict number value type.
+ * When props.type is 'number', value must be number.
+ */
+interface NumberInputField<TProps extends {
+    type?: string;
+} = {
+    type: 'number';
+    placeholder?: DynamicText;
+}> extends BaseValueField<TProps, number> {
+    type: 'input';
+    props?: TProps;
+}
+/**
+ * String input field with strict string value type.
+ * When props.type is text/email/etc, value must be string.
+ */
+interface StringInputField<TProps extends {
+    type?: string;
+} = {
+    type: 'text' | 'email' | 'password' | 'tel' | 'url';
+    placeholder?: DynamicText;
+}> extends BaseValueField<TProps, string> {
+    type: 'input';
+    props?: TProps;
+}
+/**
+ * Helper type to extract the input type from props
+ */
+type ExtractInputType<TProps> = TProps extends {
+    type?: infer T;
+} ? T : InputType;
+/**
+ * Fallback variant when props is undefined - allows both string and number values
+ */
+interface UndefinedPropsInputField extends BaseValueField<undefined, string | number> {
+    type: 'input';
+    props?: never;
+}
+/**
+ * Builds discriminated union based on what input types are possible in TProps
+ */
+type BuildInputFieldUnion<TProps extends {
+    type?: string;
+}> = (ExtractInputType<TProps> extends infer T ? T extends string ? ('number' extends T ? NumberInputField<TProps> : never) | (Exclude<T, 'number'> extends never ? never : StringInputField<TProps>) : StringInputField<TProps> : never) | UndefinedPropsInputField;
+/**
+ * Input field with automatic type-safe value inference.
+ * TypeScript automatically infers the correct value type based on props.type.
+ *
+ * @example
+ * // Direct usage - automatic strict type safety
+ * const numberField: InputField = {
+ *   type: 'input',
+ *   key: 'age',
+ *   props: { type: 'number' },
+ *   value: 25 // ✓ number only (string is type error!)
+ * };
+ *
+ * const textField: InputField = {
+ *   type: 'input',
+ *   key: 'name',
+ *   props: { type: 'text' },
+ *   value: 'hello' // ✓ string only (number is type error!)
+ * };
+ *
+ * @example
+ * // Framework usage - extend with custom props
+ * interface MatInputProps extends InputProps {
+ *   appearance?: 'fill' | 'outline';
+ *   hint?: string;
+ * }
+ * type MatInputField = InputField<MatInputProps>; // Automatically gets discriminated union
+ */
+type InputField<TProps extends {
+    type?: string;
+} = InputProps> = BuildInputFieldUnion<TProps>;
+
+interface CheckboxField<TProps> extends BaseCheckedField<TProps> {
+    type: 'checkbox';
+}
+
+interface SelectProps {
+    placeholder?: DynamicText;
+}
+interface SelectField<T, TProps = SelectProps> extends BaseValueField<TProps, T> {
+    type: 'select';
+    readonly options: readonly FieldOption<T>[];
+}
+
+/**
+ * Event arguments that can contain static values or tokens to be resolved at runtime
+ * Tokens supported: $key, $index, $arrayKey, formValue
+ */
+type EventArgs = readonly (string | number | boolean | null | undefined)[];
+/**
+ * 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)
+     * - formValue: Access to the current form value for indexing
+     *
+     * @example
+     * eventArgs: ['$arrayKey', '$index']
+     * eventArgs: ['contacts', 0]
+     */
+    eventArgs?: EventArgs;
+}
+
+interface TextareaProps {
+    placeholder?: DynamicText;
+    rows?: number;
+    cols?: number | undefined;
+}
+interface TextareaField<TProps = TextareaProps> extends BaseValueField<TProps, string> {
+    type: 'textarea';
+    maxLength?: number | undefined;
+}
+
+interface RadioField<T, TProps> extends BaseValueField<TProps, T> {
+    type: 'radio';
+    options: FieldOption<T>[];
+}
+
+/**
+ * Multi-checkbox field for selecting multiple values from a list of options.
+ * The value is an array of selected option values.
+ *
+ * @example
+ * const tagsField: MultiCheckboxField<string> = {
+ *   type: 'multi-checkbox',
+ *   key: 'tags',
+ *   value: ['tag1', 'tag2'], // Array of selected values
+ *   options: [
+ *     { label: 'Tag 1', value: 'tag1' },
+ *     { label: 'Tag 2', value: 'tag2' },
+ *     { label: 'Tag 3', value: 'tag3' }
+ *   ]
+ * };
+ */
+interface MultiCheckboxField<TValue, TProps = object> extends BaseValueField<TProps, TValue[]> {
+    type: 'multi-checkbox';
+    options: FieldOption<TValue>[];
+}
+
+interface DatepickerProps {
+    placeholder?: DynamicText;
+}
+interface DatepickerField<TProps> extends BaseValueField<TProps, Date | string> {
+    type: 'datepicker';
+    minDate?: Date | string | null;
+    maxDate?: Date | string | null;
+    startAt?: Date | null;
+}
+
+interface SliderField<TProps> extends BaseValueField<TProps, number> {
+    type: 'slider';
+    minValue?: number;
+    maxValue?: number;
+    step?: number;
+}
+
+interface ToggleField<TProps> extends BaseCheckedField<TProps> {
+    type: 'toggle';
+}
+
+/**
+ * Apply validator configuration to field path, following the logic pattern.
+ *
+ * Accepts both SchemaPath and SchemaPathTree to support being called from both
+ * individual field mappings and schema functions.
+ *
+ * Note: ValidatorConfig is runtime configuration that doesn't encode the field's
+ * TypeScript type. The type assertions to specific types (string, number) are safe
+ * because Angular's validators perform runtime value checks regardless of the static
+ * type parameter.
+ *
+ * Cross-field validators (those referencing formValue.*) are skipped at field level.
+ * They are collected by the parent form component using collectCrossFieldEntries
+ * and executed at form level using validateTree.
+ *
+ * @param config The validator configuration
+ * @param fieldPath The field path to apply the validator to
+ * @param fieldKey Optional field key (used for logging)
+ */
+declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>, fieldKey?: string): void;
+/**
+ * Apply multiple validators to a field path
+ *
+ * @param configs Array of validator configurations
+ * @param fieldPath The field path to apply validators to
+ * @param fieldKey Optional field key (used for logging)
+ */
+declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>, fieldKey?: string): void;
+
+declare class SubmitEvent implements FormEvent {
+    readonly type: "submit";
+}
+
+declare class NextPageEvent implements FormEvent {
+    readonly type: "next-page";
+}
+
+declare class PreviousPageEvent implements FormEvent {
+    readonly type: "previous-page";
+}
+
+/**
+ * Event dispatched to add a new item to an array field.
+ *
+ * This event is used to dynamically add items to array fields at runtime.
+ * The array field component listens for this event and adds a new item
+ * based on the provided field template, or uses the array's own template if not provided.
+ *
+ * @example
+ * ```typescript
+ * // Add item using array's own template
+ * eventBus.dispatch(AddArrayItemEvent, 'contacts');
+ *
+ * // Add item with explicit field template
+ * const fieldTemplate = { key: 'email', type: 'input' };
+ * eventBus.dispatch(AddArrayItemEvent, 'contacts', fieldTemplate);
+ *
+ * // Add item at specific index
+ * eventBus.dispatch(AddArrayItemEvent, 'contacts', fieldTemplate, 2);
+ * ```
+ */
+declare class AddArrayItemEvent implements FormEvent {
+    /** The key of the array field to add an item to */
+    readonly arrayKey: string;
+    /**
+     * Optional field template definition to render for the new array item.
+     * If not provided, the array field component will use its own template.
+     */
+    readonly field?: ArrayAllowedChildren | undefined;
+    /** Optional index where to insert the item (defaults to end of array) */
+    readonly index?: number | undefined;
+    readonly type: "add-array-item";
+    constructor(
+    /** The key of the array field to add an item to */
+    arrayKey: string, 
+    /**
+     * Optional field template definition to render for the new array item.
+     * If not provided, the array field component will use its own template.
+     */
+    field?: ArrayAllowedChildren | undefined, 
+    /** Optional index where to insert the item (defaults to end of array) */
+    index?: number | undefined);
+}
+
+/**
+ * Event dispatched to remove an item from an array field.
+ *
+ * This event is used to dynamically remove items from array fields at runtime.
+ * The array field component listens for this event and removes the item
+ * at the specified index.
+ *
+ * @example
+ * ```typescript
+ * // Remove item at index 1 from 'contacts' array
+ * eventBus.dispatch(RemoveArrayItemEvent, 'contacts', 1);
+ *
+ * // Remove last item
+ * eventBus.dispatch(RemoveArrayItemEvent, 'contacts');
+ * ```
+ */
+declare class RemoveArrayItemEvent implements FormEvent {
+    /** The key of the array field to remove an item from */
+    readonly arrayKey: string;
+    /** Index of the item to remove (defaults to last item) */
+    readonly index?: number | undefined;
+    readonly type: "remove-array-item";
+    constructor(
+    /** The key of the array field to remove an item from */
+    arrayKey: string, 
+    /** Index of the item to remove (defaults to last item) */
+    index?: number | undefined);
+}
+
+/**
+ * Event bus service for form-wide event communication.
+ *
+ * Provides type-safe event dispatching and subscription for form components
+ * to communicate without direct coupling. Uses RxJS observables for reactive
+ * event handling and supports both single event type and multiple event type subscriptions.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [EventBus]
+ * })
+ * export class MyFormComponent {
+ *   constructor(private eventBus: EventBus) {
+ *     // Subscribe to form submission events
+ *     this.eventBus.on<SubmitEvent>('submit').subscribe(() => {
+ *       console.log('Form was submitted');
+ *     });
+ *
+ *     // Subscribe to multiple event types
+ *     this.eventBus.on<SubmitEvent | FormResetEvent>(['submit', 'form-reset']).subscribe(event => {
+ *       console.log('Form event:', event.type);
+ *     });
+ *   }
+ *
+ *   onSubmit() {
+ *     // Dispatch a submit event
+ *     this.eventBus.dispatch(SubmitEvent);
+ *   }
+ * }
+ * ```
+ */
+declare class EventBus {
+    private pipeline$;
+    events$: Observable<FormEvent>;
+    /**
+     * Dispatches an event to all subscribers.
+     *
+     * Creates an instance of the provided event constructor and broadcasts it
+     * through the event pipeline to all active subscribers.
+     *
+     * @param eventConstructor - Constructor function for the event to dispatch
+     *
+     * @example
+     * ```typescript
+     * // Dispatch a submit event
+     * eventBus.dispatch(SubmitEvent);
+     *
+     * // Dispatch a custom event
+     * eventBus.dispatch(CustomFormEvent);
+     * ```
+     */
+    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: any[]): void;
+    /**
+     * Subscribes to events of a specific type.
+     *
+     * @param eventType - The type of event to subscribe to
+     * @returns Observable that emits events of the specified type
+     */
+    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
+    /**
+     * Subscribes to events of multiple types.
+     *
+     * @param eventType - Array of event types to subscribe to
+     * @returns Observable that emits events matching any of the specified types
+     */
+    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventBus, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventBus>;
+}
+
+/**
+ * Context for token resolution in event args
+ */
+interface TokenContext {
+    /** Current field key */
+    key?: string;
+    /** Array index if field is inside an array */
+    index?: number;
+    /** Parent array field key if field is inside an array */
+    arrayKey?: string;
+    /** Current form value for complex indexing */
+    formValue?: unknown;
+}
+/**
+ * Resolves special tokens in event arguments to their actual values
+ *
+ * Supported tokens:
+ * - $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)
+ * - formValue: Reference to the current form value for indexing
+ *
+ * @param args - Array of arguments that may contain tokens
+ * @param context - Context object containing token values
+ * @returns Array with resolved values
+ *
+ * @example
+ * resolveTokens(['$arrayKey', '$index'], { arrayKey: 'contacts', index: 2 })
+ * // Returns: ['contacts', 2]
+ *
+ * @example
+ * resolveTokens(['$key', 'static'], { key: 'myField' })
+ * // Returns: ['myField', 'static']
+ */
+declare function resolveTokens(args: readonly (string | number | boolean | null | undefined)[], context: TokenContext): (string | number | boolean | null | undefined | unknown)[];
+
+/**
+ * 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;
+}
+
+/**
+ * Maps a value field definition to component inputs.
+ *
+ * Value fields are input fields that contribute to the form's value (text, number, etc.).
+ * This mapper injects FIELD_SIGNAL_CONTEXT to access the form structure and retrieve the field proxy.
+ *
+ * For fields with specific properties (select, datepicker, textarea, slider), use the specialized mappers:
+ * - selectFieldMapper: for fields with options (select, radio, multi-checkbox)
+ * - datepickerFieldMapper: for fields with minDate, maxDate, startAt
+ * - textareaFieldMapper: for fields with rows, cols
+ * - sliderFieldMapper: for fields with minValue, maxValue, step
+ *
+ * @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>): Signal<Record<string, unknown>>;
+
+/**
+ * Builds base input properties from a field definition.
+ *
+ * This is a helper function that extracts common field properties.
+ * Used by mappers to build the inputs record.
+ *
+ * @param fieldDef The field definition to extract properties from
+ * @returns Record of input names to values
+ */
+declare function buildBaseInputs(fieldDef: FieldDef<unknown>): Record<string, unknown>;
+/**
+ * Base field mapper that extracts common field properties into component inputs.
+ *
+ * Returns a Signal containing the Record of input names to values that will be
+ * passed to ngComponentOutlet. The signal enables reactive updates.
+ *
+ * @param fieldDef The field definition to map
+ * @returns Signal containing Record of input names to values
+ */
+declare function baseFieldMapper(fieldDef: FieldDef<unknown>): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a checkbox/toggle field definition to component inputs.
+ *
+ * Checkbox fields are checked fields that contribute to the form's value as boolean.
+ * This mapper injects FIELD_SIGNAL_CONTEXT to access the form structure and retrieve the field proxy.
+ *
+ * @param fieldDef The checkbox field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function checkboxFieldMapper(fieldDef: BaseCheckedField<unknown>): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a row field definition to component inputs.
+ *
+ * Row components are layout containers that don't change the form shape.
+ * The row component will inject FIELD_SIGNAL_CONTEXT directly.
+ *
+ * @param fieldDef The row field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function rowFieldMapper(fieldDef: RowField): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a group field definition to component inputs.
+ *
+ * Group components create nested form structures under the group's key.
+ * The group component will inject the parent FIELD_SIGNAL_CONTEXT and create
+ * a scoped child injector for its nested fields.
+ *
+ * @param fieldDef The group field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function groupFieldMapper(fieldDef: GroupField): Signal<Record<string, unknown>>;
+
+/**
+ * Maps an array field definition to component inputs.
+ *
+ * Array components create nested form structures under the array's key.
+ * The array component will inject the parent FIELD_SIGNAL_CONTEXT and create
+ * a scoped child injector for its array item fields.
+ *
+ * @param fieldDef The array field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function arrayFieldMapper(fieldDef: ArrayField): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a page field definition to component inputs.
+ *
+ * Page fields are layout containers that don't modify the form context.
+ * The page component will inject FIELD_SIGNAL_CONTEXT directly.
+ *
+ * @param fieldDef The page field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function pageFieldMapper(fieldDef: PageField): 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>;
+/**
+ * Maps a field with options (select, radio, multi-checkbox) to component inputs.
+ *
+ * Extends the base value field mapper by adding the options property.
+ *
+ * @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>>;
+
+/**
+ * Maps a datepicker field to component inputs.
+ *
+ * Extends the base value field mapper by adding datepicker-specific properties:
+ * - minDate: Minimum selectable date
+ * - maxDate: Maximum selectable date
+ * - startAt: Initial date to display when opening the picker
+ *
+ * @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>>;
+
+/**
+ * Converts DynamicText (string | Observable | Signal) to Observable<string>
+ * Unifies all three types into a consistent Observable stream
+ *
+ * @param value - The dynamic text value to convert
+ * @param injector - Optional injector for signal conversion
+ * @returns Observable<string> - The value as an observable stream
+ */
+declare function dynamicTextToObservable(value: DynamicText | undefined, injector?: Injector): Observable<string>;
+
+/**
+ * Computed signal that determines if errors should be displayed
+ * Based on field's invalid, touched, and error count
+ *
+ * @param field - Signal containing FieldTree
+ * @returns Signal<boolean> - True if errors should be displayed
+ */
+declare function shouldShowErrors<T>(field: Signal<FieldTree<T>>): Signal<boolean>;
+
+/**
+ * Resolved validation error with interpolated message
+ */
+interface ResolvedError {
+    kind: string;
+    message: string;
+}
+/**
+ * Factory function that creates a signal of resolved validation errors
+ * Handles async resolution of DynamicText validation messages
+ *
+ * @param field - Signal containing FieldTree
+ * @param validationMessages - Signal containing custom field-level validation messages
+ * @param defaultValidationMessages - Signal containing default validation messages (fallback)
+ * @param injector - Optional injector for DynamicText resolution
+ * @returns Signal<ResolvedError[]> - Reactively resolved error messages
+ *
+ * @example
+ * ```typescript
+ * readonly resolvedErrors = createResolvedErrorsSignal(
+ *   this.field,
+ *   this.validationMessages,
+ *   this.defaultValidationMessages
+ * );
+ * ```
+ */
+declare function createResolvedErrorsSignal<T>(field: Signal<FieldTree<T>>, validationMessages: Signal<ValidationMessages | undefined>, defaultValidationMessages?: Signal<ValidationMessages | undefined>, injector?: Injector): Signal<ResolvedError[]>;
+
+/**
+ * Internal Angular Signal Forms structure interface.
+ *
+ * WARNING: These properties are internal Angular APIs and may change between versions.
+ * This interface documents our dependency on Angular internals for form structure access.
+ *
+ * Used to access:
+ * - `structure.childrenMap()` - Map of child field keys to their FieldTree instances
+ * - `fieldProxy` - The FieldTree proxy for a FieldNode
+ */
+interface FormInternals<T = unknown> {
+    /**
+     * Internal structure containing form graph information.
+     * Present on forms created via `form()` function.
+     */
+    structure?: {
+        /**
+         * Returns a Map of child field keys to their FieldTree instances.
+         * Keys are strings for object properties or stringified indices for arrays.
+         */
+        childrenMap?: () => Map<string, FieldTree<unknown>>;
+    };
+    /**
+     * The FieldTree proxy for navigating the form graph.
+     * Present on FieldNode instances.
+     */
+    fieldProxy?: FieldTree<T>;
+}
+/**
+ * Type guard for checking if a form-like object has the internal structure property.
+ *
+ * @param form - The form object to check
+ * @returns True if the form has a structure property with childrenMap
+ */
+declare function hasFormStructure(form: unknown): form is FormInternals;
+/**
+ * Safely retrieves the childrenMap from a form's internal structure.
+ *
+ * @param form - The form object (from `form()` function or FieldTree)
+ * @returns The childrenMap or null if not available
+ */
+declare function getChildrenMap(form: unknown): Map<string, FieldTree<unknown>> | null;
+/**
+ * Safely retrieves the fieldProxy from a form node.
+ *
+ * @param node - The form node (FieldNode or similar)
+ * @returns The fieldProxy FieldTree or null if not available
+ */
+declare function getFieldProxy<T = unknown>(node: unknown): FieldTree<T> | null;
+/**
+ * Retrieves a child FieldTree from a form by key.
+ *
+ * @param form - The parent form
+ * @param key - The child field key
+ * @returns The child FieldTree or null if not found
+ */
+declare function getChildFieldTree(form: unknown, key: string): FieldTree<unknown> | null;
+
+/**
+ * Pipe that handles dynamic text resolution with support for static strings,
+ * Observables, and Signals.
+ *
+ * Supports:
+ * - Static strings (pass-through)
+ * - Observables (subscribed internally)
+ * - Signals (converted to Observable using toObservable for reactivity)
+ *
+ * @example
+ * ```html
+ * <!-- Static string -->
+ * {{ 'Hello World' | dynamicText | async }}
+ *
+ * <!-- Observable -->
+ * {{ transloco.selectTranslate('key') | dynamicText | async }}
+ *
+ * <!-- Signal -->
+ * {{ myTextSignal | dynamicText | async }}
+ * ```
+ *
+ * @public
+ */
+declare class DynamicTextPipe implements PipeTransform {
+    private readonly injector;
+    /**
+     * Transforms dynamic text input into a resolved string value
+     *
+     * @param value - The dynamic text value to resolve
+     * @returns The resolved string value as an Observable
+     */
+    transform(value: DynamicText | undefined): Observable<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicTextPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DynamicTextPipe, "dynamicText", true>;
+}
+
+/**
+ * Layout container for horizontal field arrangement.
+ *
+ * Does not create a new form context - fields share the parent's context.
+ * Field values are flattened into the parent form (no nesting under row key).
+ * Purely a visual/layout container with no impact on form structure.
+ */
+declare class RowFieldComponent {
+    private readonly destroyRef;
+    private readonly fieldRegistry;
+    private readonly injector;
+    private readonly eventBus;
+    field: _angular_core.InputSignal<RowField<readonly _ng_forge_dynamic_forms.RowAllowedChildren[]>>;
+    key: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    private readonly rawFieldRegistry;
+    private readonly fieldsSource;
+    protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
+    private readonly emitInitializedOnFieldsResolved;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowFieldComponent, "div[row-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Container component for rendering nested form groups.
+ *
+ * Creates a scoped form context with its own validation state.
+ * Child fields receive a FIELD_SIGNAL_CONTEXT scoped to this group's form instance.
+ * Group values are nested under the group's key in the parent form.
+ */
+declare class GroupFieldComponent<TModel = Record<string, unknown>> {
+    private readonly destroyRef;
+    private readonly fieldRegistry;
+    private readonly parentFieldSignalContext;
+    private readonly injector;
+    private readonly eventBus;
+    private readonly memoizedFlattenFields;
+    private readonly memoizedKeyBy;
+    private readonly memoizedDefaultValues;
+    field: _angular_core.InputSignal<GroupField<readonly _ng_forge_dynamic_forms.GroupAllowedChildren[]>>;
+    key: _angular_core.InputSignal<string>;
+    private readonly rawFieldRegistry;
+    private readonly formSetup;
+    readonly defaultValues: _angular_core.WritableSignal<Record<string, unknown>>;
+    private readonly entity;
+    private readonly form;
+    readonly formValue: _angular_core.Signal<{}>;
+    readonly valid: _angular_core.Signal<boolean>;
+    readonly invalid: _angular_core.Signal<boolean>;
+    readonly dirty: _angular_core.Signal<boolean>;
+    readonly touched: _angular_core.Signal<boolean>;
+    readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    /**
+     * Get the nested FieldTree from the parent form for this group.
+     * This allows child fields to update the parent form directly,
+     * avoiding the need for separate form synchronization.
+     */
+    private readonly nestedFieldTree;
+    private readonly groupInjector;
+    readonly validityChange: _angular_core.OutputRef<boolean>;
+    readonly dirtyChange: _angular_core.OutputRef<boolean>;
+    readonly submitted: _angular_core.OutputRef<SubmitEvent>;
+    private readonly fieldsSource;
+    protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
+    private readonly emitInitializedOnFieldsResolved;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupFieldComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupFieldComponent<any>, "fieldset[group-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, { "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; }, never, never, true, never>;
+}
+
+/**
+ * Resolved array item ready for declarative rendering with ngComponentOutlet.
+ * Each item has a stable unique ID and a linkedSignal-based index that
+ * automatically updates when items are added/removed.
+ */
+interface ResolvedArrayItem {
+    /** Unique identifier for this item (stable across position changes). */
+    id: string;
+    /** The loaded component type. */
+    component: Type<unknown>;
+    /** Injector providing ARRAY_CONTEXT and FIELD_SIGNAL_CONTEXT. */
+    injector: Injector;
+    /** Inputs signal for ngComponentOutlet - evaluated in template for reactivity. */
+    inputs: Signal<Record<string, unknown>>;
+}
+
+/**
+ * Container component for rendering dynamic arrays of fields.
+ *
+ * Supports add/remove operations via AddArrayItemEvent and RemoveArrayItemEvent.
+ * Uses differential updates to optimize rendering - only recreates items when necessary.
+ * Each item gets a scoped injector with ARRAY_CONTEXT for position-aware operations.
+ */
+declare class ArrayFieldComponent<TModel = Record<string, unknown>> {
+    private readonly destroyRef;
+    private readonly fieldRegistry;
+    private readonly parentFieldSignalContext;
+    private readonly parentInjector;
+    private readonly eventBus;
+    field: _angular_core.InputSignal<ArrayField<readonly _ng_forge_dynamic_forms.ArrayAllowedChildren[]>>;
+    key: _angular_core.InputSignal<string>;
+    private readonly rawFieldRegistry;
+    private readonly fieldTemplate;
+    private readonly arrayFieldTrees;
+    private readonly resolvedItemsSignal;
+    private readonly updateVersion;
+    private readonly itemOrderSignal;
+    readonly resolvedItems: _angular_core.WritableSignal<ResolvedArrayItem[]>;
+    private readonly syncFieldsOnArrayChange;
+    private readonly handleAddItem;
+    private readonly handleRemoveItem;
+    private performDifferentialUpdate;
+    private resolveAllItems;
+    private appendItems;
+    private createResolveItemObservable;
+    private addItem;
+    private removeItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrayFieldComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayFieldComponent<any>, "array-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Injection function for accessing the dynamic form field registry.
+ *
+ * Provides a convenient API for interacting with registered field types,
+ * including type checking, component loading, and registration management.
+ * Must be called within an injection context.
+ *
+ * @returns Object with methods for field registry interaction
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class MyComponent {
+ *   private fieldRegistry = injectFieldRegistry();
+ *
+ *   async loadCustomField() {
+ *     if (this.fieldRegistry.hasType('custom-input')) {
+ *       const component = await this.fieldRegistry.loadTypeComponent('custom-input');
+ *       // Use component...
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In a service
+ * @Injectable()
+ * export class FormBuilderService {
+ *   private fieldRegistry = injectFieldRegistry();
+ *
+ *   getAvailableFieldTypes(): string[] {
+ *     return this.fieldRegistry.getTypes().map(type => type.name);
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function injectFieldRegistry(): {
+    /**
+     * Retrieves a field type definition by its registered name.
+     *
+     * @param name - The registered name of the field type
+     * @returns The field type definition if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const inputType = fieldRegistry.getType('input');
+     * if (inputType) {
+     *   console.log('Input field type found:', inputType.name);
+     * }
+     * ```
+     */
+    getType(name: string): FieldTypeDefinition | undefined;
+    /**
+     * Checks if a field type is registered in the registry.
+     *
+     * @param name - The name of the field type to check
+     * @returns True if the field type exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (fieldRegistry.hasType('custom-input')) {
+     *   // Safe to use custom-input field type
+     *   const component = await fieldRegistry.loadTypeComponent('custom-input');
+     * }
+     * ```
+     */
+    hasType(name: string): boolean;
+    /**
+     * Loads a field type component with support for lazy loading.
+     *
+     * Handles both synchronous component references and asynchronous
+     * dynamic imports. Automatically extracts default exports from ES modules.
+     *
+     * @param name - The name of the field type to load
+     * @returns Promise resolving to the component constructor
+     * @throws {Error} When field type is not registered or loading fails
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const InputComponent = await fieldRegistry.loadTypeComponent('input');
+     *   const componentRef = vcr.createComponent(InputComponent);
+     * } catch (error) {
+     *   console.error('Failed to load component:', error);
+     * }
+     * ```
+     */
+    loadTypeComponent(name: string): Promise<Type<unknown>>;
+    /**
+     * Gets all registered field type definitions.
+     *
+     * @returns Array of all field type definitions in the registry
+     *
+     * @example
+     * ```typescript
+     * const allTypes = fieldRegistry.getTypes();
+     * const typeNames = allTypes.map(type => type.name);
+     * console.log('Available field types:', typeNames);
+     * ```
+     */
+    getTypes(): FieldTypeDefinition[];
+    /**
+     * Registers multiple field types at once.
+     *
+     * Useful for bulk registration of custom field types. Overwrites
+     * existing registrations with the same name.
+     *
+     * @param types - Array of field type definitions to register
+     *
+     * @example
+     * ```typescript
+     * fieldRegistry.registerTypes([
+     *   CustomInputType,
+     *   CustomSelectType,
+     *   CustomDatePickerType
+     * ]);
+     * ```
+     */
+    registerTypes(types: FieldTypeDefinition[]): void;
+    /**
+     * Provides direct access to the underlying registry Map.
+     *
+     * Use with caution - direct modification can affect form behavior.
+     * Primarily intended for advanced use cases and debugging.
+     *
+     * @returns The raw Map containing field type registrations
+     *
+     * @example
+     * ```typescript
+     * const rawRegistry = fieldRegistry.raw;
+     * console.log('Registry size:', rawRegistry.size);
+     * ```
+     */
+    readonly raw: Map<string, FieldTypeDefinition<any>>;
+};
+
+export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, DynamicForm, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FormClearEvent, FormResetEvent, GroupFieldComponent, NextPageEvent, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RowFieldComponent, SubmitEvent, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, checkboxFieldMapper, createResolvedErrorsSignal, datepickerFieldMapper, dynamicTextToObservable, getChildFieldTree, getChildrenMap, getFieldProxy, getFieldValueHandling, groupFieldMapper, hasFormStructure, injectFieldRegistry, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, optionsFieldMapper, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, shouldShowErrors, valueFieldMapper };
+export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonField, ButtonLogicContext, CheckboxField, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DatepickerField, DatepickerProps, DynamicFormFieldRegistry, DynamicText, EvaluationContext, EventArgs, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormInternals, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, InputField, InputProps, LeafFieldTypes, LogicConfig, MapperFn, MultiCheckboxField, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RadioField, RegisteredFieldTypes, ResolvedError, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SelectField, SelectProps, SliderField, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TextareaField, TextareaProps, ToggleField, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };