@ng-forge/dynamic-forms 0.1.1 → 0.1.3

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

@@ -2,10 +2,10 @@ 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 { ValidationError as ValidationError$1, FieldContext, TreeValidationResult, FieldTree, Schema, 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';
+import { Signal, ResourceRef, Injector, WritableSignal, InjectionToken, Type, OnDestroy, InputSignal, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
 
 type WithInputSignals<T> = {
     readonly [K in keyof T]-?: Signal<T[K]>;
@@ -654,6 +654,57 @@ type RegisteredFieldTypes = ContainerFieldTypes | LeafFieldTypes;
  * Extract field types that are available in the registry
  */
 type AvailableFieldTypes = keyof DynamicFormFieldRegistry['containers'] | keyof DynamicFormFieldRegistry['leaves'];
+/**
+ * Combined registry mapping type names to field definitions.
+ * This flattens containers and leaves into a single mapping.
+ */
+type FieldTypeMap = DynamicFormFieldRegistry['containers'] & DynamicFormFieldRegistry['leaves'];
+/**
+ * Extract a specific field type from RegisteredFieldTypes based on the `type` discriminant.
+ * This enables proper type narrowing when defining fields.
+ *
+ * @example
+ * ```typescript
+ * // Extract a specific field type
+ * type MyInputField = ExtractField<'input'>;
+ *
+ * // Use in field definitions for proper props inference
+ * const field: ExtractField<'input'> = {
+ *   type: 'input',
+ *   key: 'email',
+ *   value: '',
+ *   props: { type: 'email' } // Only input props allowed here
+ * };
+ * ```
+ */
+type ExtractField<T extends AvailableFieldTypes> = T extends keyof FieldTypeMap ? FieldTypeMap[T] : never;
+/**
+ * Narrow a field definition based on its `type` property.
+ * Use this to get proper type inference when working with field unions.
+ *
+ * @example
+ * ```typescript
+ * function processField<T extends RegisteredFieldTypes>(field: T): NarrowField<T> {
+ *   return field as NarrowField<T>;
+ * }
+ * ```
+ */
+type NarrowField<T> = T extends {
+    type: infer TType;
+} ? (TType extends AvailableFieldTypes ? ExtractField<TType> : T) : T;
+/**
+ * Narrow each field in an array based on its `type` property.
+ * Use with `satisfies` to get proper type inference for field arrays.
+ *
+ * @example
+ * ```typescript
+ * const fields = [
+ *   { type: 'input', key: 'name', value: '', props: { type: 'text' } },
+ *   { type: 'select', key: 'country', value: 'us', options: [...] },
+ * ] as const satisfies NarrowFields;
+ * ```
+ */
+type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
 
 /**
  * Helper type to convert union to intersection
@@ -664,27 +715,49 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * Depth counter for recursion limiting (prevents infinite type instantiation)
  */
 type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+/**
+ * Widens literal types to their primitive equivalents.
+ * This prevents `as const` from over-narrowing types like `''` to literal `''` instead of `string`.
+ *
+ * @example
+ * ```typescript
+ * type A = Widen<''>; // string
+ * type B = Widen<false>; // boolean
+ * type C = Widen<42>; // number
+ * type D = Widen<string[]>; // string[]
+ * ```
+ */
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+/**
+ * Infer value type based on field type and props.
+ * - Slider fields: always number
+ * - Input fields with props.type: 'number': number
+ * - Other fields: widen the literal value type
+ */
+type InferValueType<T, V> = T extends {
+    type: 'slider';
+} ? number : T extends {
+    type: 'input';
+    props: {
+        type: 'number';
+    };
+} ? number : Widen<V>;
+/** Make type optional if field is not required */
+type MaybeOptional<T, V> = T extends {
+    required: true;
+} ? V : V | undefined;
 /**
  * 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: 'page' | 'row';
+    fields: infer F;
+} ? F extends RegisteredFieldTypes[] ? InferFormValueWithDepth<F, 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]>;
+    fields: infer F;
+} ? K extends string ? F extends RegisteredFieldTypes[] ? {
+    [P in K]: InferFormValueWithDepth<F, Depth[D]>;
 } : {
     [P in K]: Record<string, unknown>;
 } : never : T extends {
@@ -692,39 +765,46 @@ type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string
 } ? 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;
+    [P in K]: MaybeOptional<T, InferValueType<T, V>>;
 } : 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
+ * Helper to extract fields from either fields array or FormConfig
+ */
+type ExtractFields<T> = T extends {
+    fields: infer TFields;
+} ? TFields extends readonly RegisteredFieldTypes[] ? TFields : never : T extends readonly RegisteredFieldTypes[] ? T : never;
+/**
+ * Infer form value type from fields array or FormConfig.
+ * Recursively processes nested structures and merges the results.
+ * Limited to 5 levels of nesting to prevent infinite type instantiation.
  *
  * @example
  * ```typescript
+ * // From fields array
  * const fields = [
  *   { type: 'input', key: 'email', value: '', required: true },
- *   { type: 'group', key: 'address', fields: [
- *     { type: 'input', key: 'street', value: '' },
- *     { type: 'input', key: 'city', value: '' }
- *   ]}
+ *   { type: 'input', key: 'name', value: '' }
  * ] as const;
+ * type FieldsValue = InferFormValue<typeof fields>;
  *
- * type FormValue = InferFormValue<typeof fields>;
- * // Result: { email: string; address: { street?: string; city?: string } }
+ * // From FormConfig
+ * const config = {
+ *   fields: [
+ *     { type: 'input', key: 'email', value: '', required: true },
+ *     { type: 'input', key: 'name', value: '' }
+ *   ]
+ * } as const satisfies FormConfig;
+ * type ConfigValue = InferFormValue<typeof config>;
+ *
+ * // Result: { email: string; name?: string }
  * ```
  */
-type InferFormValue$1<T extends RegisteredFieldTypes[]> = InferFormValueWithDepth<T, 5>;
+type InferFormValue$1<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<ExtractFields<T> extends RegisteredFieldTypes[] ? ExtractFields<T> : [...ExtractFields<T>], 5> : never;
 
 /**
  * Base configuration shared by all validators
@@ -1003,7 +1083,7 @@ interface AsyncCustomValidator<TValue = unknown, TParams = unknown, TResult = un
 interface HttpResourceRequest {
     url: string;
     method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    body?: any;
+    body?: unknown;
     headers?: Record<string, string | string[]>;
 }
 /**
@@ -1100,6 +1180,33 @@ interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
     readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
 }
 
+/**
+ * Interface for dynamic forms logger implementations.
+ * Allows custom logging integrations (Sentry, DataDog, etc.)
+ */
+interface DynamicFormLogger {
+    /**
+     * Log a debug message.
+     * Use for detailed diagnostic information during development.
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Log an info message.
+     * Use for general operational information.
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message.
+     * Use for potentially problematic situations that don't prevent operation.
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message.
+     * Use for error conditions that may affect functionality.
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+
 interface EvaluationContext<TValue = unknown> {
     /** Current field value */
     fieldValue: TValue;
@@ -1109,6 +1216,8 @@ interface EvaluationContext<TValue = unknown> {
     fieldPath: string;
     /** Custom evaluation functions */
     customFunctions?: Record<string, (context: EvaluationContext) => unknown>;
+    /** Logger for diagnostic output */
+    logger: DynamicFormLogger;
     /** Allow additional properties for flexible expression evaluation */
     [key: string]: unknown;
 }
@@ -1290,19 +1399,18 @@ interface SubmissionConfig<TValue = unknown> {
  *
  * @example
  * ```typescript
- * const formConfig: FormConfig = {
+ * const formConfig = {
  *   fields: [
- *     { type: 'input', key: 'email', value: '', label: 'Email', required: true, email: true },
+ *     { type: 'input', key: 'email', value: '', label: 'Email', required: 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 } }
- *   ]
- * };
+ * } as const satisfies FormConfig;
+ *
+ * // Infer form value type from config
+ * type FormValue = InferFormValue<typeof formConfig>;
  * ```
  *
  * @typeParam TFields - Array of registered field types available for this form
@@ -1310,7 +1418,7 @@ interface SubmissionConfig<TValue = unknown> {
  *
  * @public
  */
-interface FormConfig<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields>> {
+interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>> {
     /**
      * Array of field definitions that define the form structure.
      *
@@ -1773,12 +1881,15 @@ interface NextButtonOptions {
  *
  * Gives mappers and components access to form state, values, and configuration.
  * Container fields (Group, Array) create scoped contexts with nested forms.
+ *
+ * The `form` property uses Angular's FieldTree which includes Subfields<TModel>
+ * for type-safe child field access via bracket notation when TModel is a Record.
  */
-interface FieldSignalContext<TModel = unknown> {
+interface FieldSignalContext<TModel extends Record<string, unknown> = Record<string, unknown>> {
     injector: Injector;
     value: WritableSignal<Partial<TModel> | undefined>;
     defaultValues: () => TModel;
-    form: ReturnType<typeof form<TModel>>;
+    form: FieldTree<TModel>;
     defaultValidationMessages?: ValidationMessages;
     /** Form-level options used by button mappers to determine disabled state defaults. */
     formOptions?: FormOptions;
@@ -1867,14 +1978,6 @@ interface FieldTypeDefinition<T extends FieldDef<any> = any> {
  * ```
  */
 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.
@@ -2094,7 +2197,7 @@ declare class PageNavigationStateChangeEvent implements FormEvent {
  * </form>
  * ```
  */
-declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel = InferFormValue$1<TFields>> implements OnDestroy {
+declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel extends Record<string, unknown> = InferFormValue$1<TFields> & Record<string, unknown>> implements OnDestroy {
     private readonly destroyRef;
     private readonly fieldRegistry;
     private readonly injector;
@@ -2102,6 +2205,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     private readonly rootFormRegistry;
     private readonly functionRegistry;
     private readonly schemaRegistry;
+    private readonly logger;
     /** Form configuration defining the structure, validation, and behavior. */
     config: InputSignal<FormConfig<TFields>>;
     /** Runtime form options that override config options when provided. */
@@ -2151,11 +2255,6 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     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>;
@@ -2182,18 +2281,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** 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;
+    constructor();
     /**
      * Handles native form submission triggered by:
      * - Pressing Enter in an input field
@@ -2206,21 +2294,32 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
      * @param event - The native submit event from the form element
      */
     protected onNativeSubmit(event: Event): void;
+    private setupEffects;
+    private setupEventHandlers;
     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>;
 }
 
+/**
+ * Base interface for dynamic form features.
+ * Features are configuration options that can be passed to provideDynamicForm
+ * alongside field type definitions.
+ *
+ * Uses Angular-style internal marker (ɵkind) to distinguish from field types.
+ */
+interface DynamicFormFeature<TKind extends string = string> {
+    /** Internal marker to identify this as a feature, not a field type */
+    ɵkind: TKind;
+    /** Providers to register for this feature */
+    ɵproviders: Provider[];
+}
+
 /**
  * Extract FieldDef type from FieldTypeDefinition
  */
@@ -2242,13 +2341,23 @@ type ProvideDynamicFormResult<T extends FieldTypeDefinition[]> = EnvironmentProv
     __fieldDefs?: FieldDefUnion<T>;
     __formValue?: InferFormValue<FieldDefUnion<T>[]>;
 };
+/**
+ * Union type for items that can be passed to provideDynamicForm
+ */
+type FieldTypeOrFeature = FieldTypeDefinition | DynamicFormFeature;
+/**
+ * Extract only FieldTypeDefinition items from a tuple type
+ */
+type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = {
+    [K in keyof T]: T[K] extends FieldTypeDefinition ? T[K] : never;
+}[number] extends infer U ? U extends FieldTypeDefinition ? U[] : never : never;
 /**
  * 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
+ * @param items - Field type definitions and/or features (like withLogger)
  * @returns Environment providers for dependency injection with type inference
  *
  * @example
@@ -2263,6 +2372,19 @@ type ProvideDynamicFormResult<T extends FieldTypeDefinition[]> = EnvironmentProv
  *
  * @example
  * ```typescript
+ * // With logging configuration
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDynamicForm(
+ *       ...withMaterialFields(),
+ *       withLogger({ level: LogLevel.Debug })
+ *     )
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
  * // Route-level setup
  * const routes: Routes = [
  *   {
@@ -2289,7 +2411,7 @@ type ProvideDynamicFormResult<T extends FieldTypeDefinition[]> = EnvironmentProv
  *
  * @public
  */
-declare function provideDynamicForm<const T extends FieldTypeDefinition[]>(...fieldTypes: T): ProvideDynamicFormResult<T>;
+declare function provideDynamicForm<const T extends FieldTypeOrFeature[]>(...items: T): ProvideDynamicFormResult<ExtractFieldTypes<T> extends FieldTypeDefinition[] ? ExtractFieldTypes<T> : FieldTypeDefinition[]>;
 /**
  * Extract FieldDef types from provider result
  */
@@ -2336,6 +2458,97 @@ type ExtractFormValue<T> = T extends {
  */
 declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
 
+/**
+ * Log levels for the dynamic forms logger.
+ * Each level includes all levels above it (more severe).
+ *
+ * - Off: No logging
+ * - Error: Only errors
+ * - Warn: Errors + warnings
+ * - Info: Errors + warnings + info
+ * - Debug: All messages including debug
+ */
+declare enum LogLevel {
+    /** Disable all logging */
+    Off = 0,
+    /** Only log errors */
+    Error = 1,
+    /** Log errors and warnings */
+    Warn = 2,
+    /** Log errors, warnings, and info messages */
+    Info = 3,
+    /** Log all messages including debug */
+    Debug = 4
+}
+
+/**
+ * Configuration options for the logger feature
+ */
+interface LoggerFeatureOptions {
+    /**
+     * Log level to use. Messages below this level will be filtered.
+     * @default LogLevel.Warn in dev, LogLevel.Off in prod
+     */
+    level?: LogLevel;
+    /**
+     * Custom logger implementation.
+     * Use this to integrate with external logging services (Sentry, DataDog, etc.)
+     * If provided, `level` is ignored - your implementation controls filtering.
+     */
+    logger?: DynamicFormLogger;
+}
+/**
+ * Configure logging for dynamic forms.
+ *
+ * @example
+ * ```typescript
+ * // Set log level
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withLogger({ level: LogLevel.Debug })
+ * )
+ *
+ * // Disable logging entirely
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withLogger({ level: LogLevel.Off })
+ * )
+ *
+ * // Custom logger implementation
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withLogger({ logger: mySentryLogger })
+ * )
+ * ```
+ *
+ * @param options - Logger configuration options
+ * @returns A DynamicFormFeature that configures logging
+ */
+declare function withLogger(options?: LoggerFeatureOptions): DynamicFormFeature<'logger'>;
+
+/**
+ * Injection token for the dynamic forms logger.
+ *
+ * Default behavior:
+ * - Development mode: ConsoleLogger with LogLevel.Warn
+ * - Production mode: NoopLogger (silent)
+ *
+ * Override by providing a custom logger via withLogger() feature
+ * or by providing directly to this token.
+ */
+declare const DYNAMIC_FORM_LOGGER: InjectionToken<DynamicFormLogger>;
+
+/**
+ * No-operation logger implementation.
+ * All methods are no-ops - used in production by default.
+ */
+declare class NoopLogger implements DynamicFormLogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+
 interface FieldOption<T = unknown> {
     label: DynamicText;
     value: T;
@@ -2372,7 +2585,7 @@ interface FieldOption<T = unknown> {
  * }
  * ```
  */
-declare const FIELD_SIGNAL_CONTEXT: InjectionToken<FieldSignalContext<unknown>>;
+declare const FIELD_SIGNAL_CONTEXT: InjectionToken<FieldSignalContext<Record<string, unknown>>>;
 /**
  * Injection token for providing array context metadata to mappers and components.
  *
@@ -2400,8 +2613,8 @@ declare const ARRAY_CONTEXT: InjectionToken<ArrayContext>;
  * @public
  */
 interface ButtonLogicContext {
-    /** The form's FieldTree instance */
-    form: FieldTree<unknown>;
+    /** The form's FieldTree instance (supports both string and number keys for array indices) */
+    form: FieldTree<unknown, string | number>;
     /** Form-level options */
     formOptions?: FormOptions;
     /** Field-level logic array (if provided) */
@@ -2412,6 +2625,8 @@ interface ButtonLogicContext {
     currentPageValid?: Signal<boolean>;
     /** Current form value for evaluating conditional expressions */
     formValue?: unknown;
+    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
+    logger?: DynamicFormLogger;
 }
 /**
  * Resolves the disabled state for a submit button.
@@ -2511,223 +2726,8 @@ declare function isCheckedField<TProps>(field: FieldDef<TProps>): field is BaseC
 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 function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
+declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
 
 declare class SubmitEvent implements FormEvent {
     readonly type: "submit";
@@ -2935,23 +2935,6 @@ interface ArrayItemContext {
     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.
  *
@@ -2973,17 +2956,6 @@ declare function buildBaseInputs(fieldDef: FieldDef<unknown>): Record<string, un
  */
 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.
  *
@@ -3031,31 +3003,16 @@ declare function arrayFieldMapper(fieldDef: ArrayField): Signal<Record<string, u
 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.
+ * Maps a text field definition 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
+ * Text fields are display-only fields that don't participate in the form schema.
+ * This mapper handles the `logic` configuration by creating reactive signals
+ * that evaluate conditions using the form value from RootFormRegistryService.
  *
- * @param fieldDef The datepicker field definition
+ * @param fieldDef The text field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
-declare function datepickerFieldMapper<TProps>(fieldDef: DatepickerField<TProps>): Signal<Record<string, unknown>>;
+declare function textFieldMapper(fieldDef: TextField): Signal<Record<string, unknown>>;
 
 /**
  * Converts DynamicText (string | Observable | Signal) to Observable<string>
@@ -3067,65 +3024,6 @@ declare function datepickerFieldMapper<TProps>(fieldDef: DatepickerField<TProps>
  */
 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[]>;
-
-interface ChildData {
-    reader: FieldTree<unknown>;
-}
-interface ChildrenData {
-    byPropertyKey: Map<string, ChildData>;
-}
-interface FormInternals<T = unknown> {
-    structure: {
-        childrenMap: () => ChildrenData;
-    };
-    fieldProxy?: FieldTree<T>;
-}
-type FormInput = FormInternals | Signal<FormInternals> | unknown;
-/**
- * Type guard that unwraps signals and checks for FormInternals structure.
- * Use this when the input might be a signal wrapping FormInternals.
- */
-declare function hasFormStructure(form: FormInput): form is FormInternals | Signal<FormInternals>;
-declare function getChildrenMap(form: FormInput): Map<string, FieldTree<unknown>> | null;
-declare function getFieldProxy<T = unknown>(node: unknown): FieldTree<T> | null;
-declare function getChildFieldTree(form: unknown, key: string): FieldTree<unknown> | null;
-
 /**
  * Pipe that handles dynamic text resolution with support for static strings,
  * Observables, and Signals.
@@ -3174,13 +3072,15 @@ declare class RowFieldComponent {
     private readonly fieldRegistry;
     private readonly injector;
     private readonly eventBus;
+    private readonly logger;
     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;
+    constructor();
+    private setupEffects;
     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>;
 }
@@ -3192,12 +3092,13 @@ declare class RowFieldComponent {
  * 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>> {
+declare class GroupFieldComponent<TModel extends Record<string, unknown> = Record<string, unknown>> {
     private readonly destroyRef;
     private readonly fieldRegistry;
     private readonly parentFieldSignalContext;
     private readonly injector;
     private readonly eventBus;
+    private readonly logger;
     private readonly memoizedFlattenFields;
     private readonly memoizedKeyBy;
     private readonly memoizedDefaultValues;
@@ -3215,11 +3116,6 @@ declare class GroupFieldComponent<TModel = Record<string, unknown>> {
     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>;
@@ -3227,7 +3123,8 @@ declare class GroupFieldComponent<TModel = Record<string, unknown>> {
     readonly submitted: _angular_core.OutputRef<SubmitEvent>;
     private readonly fieldsSource;
     protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
-    private readonly emitInitializedOnFieldsResolved;
+    constructor();
+    private setupEffects;
     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>;
 }
@@ -3255,12 +3152,13 @@ interface ResolvedArrayItem {
  * 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>> {
+declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Record<string, unknown>> {
     private readonly destroyRef;
     private readonly fieldRegistry;
     private readonly parentFieldSignalContext;
     private readonly parentInjector;
     private readonly eventBus;
+    private readonly logger;
     field: _angular_core.InputSignal<ArrayField<readonly _ng_forge_dynamic_forms.ArrayAllowedChildren[]>>;
     key: _angular_core.InputSignal<string>;
     private readonly rawFieldRegistry;
@@ -3270,9 +3168,9 @@ declare class ArrayFieldComponent<TModel = Record<string, unknown>> {
     private readonly updateVersion;
     private readonly itemOrderSignal;
     readonly resolvedItems: _angular_core.WritableSignal<ResolvedArrayItem[]>;
-    private readonly syncFieldsOnArrayChange;
-    private readonly handleAddItem;
-    private readonly handleRemoveItem;
+    constructor();
+    private setupEffects;
+    private setupEventHandlers;
     private performDifferentialUpdate;
     private resolveAllItems;
     private appendItems;
@@ -3284,143 +3182,49 @@ declare class ArrayFieldComponent<TModel = Record<string, unknown>> {
 }
 
 /**
- * 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.
+ * Type representing a FieldTree for an array.
+ * Extends FieldTree to add numeric indexing for accessing item FieldTrees.
+ */
+type ArrayFieldTree<T> = FieldTree<T[]> & {
+    readonly [index: number]: FieldTree<T> | undefined;
+};
+/**
+ * Get the length of an array FieldTree.
+ */
+declare function getArrayLength<T>(arrayFieldTree: ArrayFieldTree<T>): number;
+
+/**
+ * Native JavaScript utility functions to replace lodash-es
+ * These are simple implementations for common object manipulation patterns
+ */
+/**
+ * Creates a new object without the specified keys
+ * Native replacement for lodash omit()
  *
- * @returns Object with methods for field registry interaction
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without specified keys
  *
  * @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...
- *     }
- *   }
- * }
+ * const obj = { a: 1, b: 2, c: 3 };
+ * omit(obj, ['b']); // { a: 1, c: 3 }
  * ```
+ */
+declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+
+/**
+ * Interpolates {{param}} placeholders in message with error values
  *
- * @example
- * ```typescript
- * // In a service
- * @Injectable()
- * export class FormBuilderService {
- *   private fieldRegistry = injectFieldRegistry();
- *
- *   getAvailableFieldTypes(): string[] {
- *     return this.fieldRegistry.getTypes().map(type => type.name);
- *   }
- * }
- * ```
+ * @param message - Message template with {{param}} placeholders
+ * @param error - Validation error containing parameter values
+ * @returns Message with interpolated parameters
  *
- * @public
+ * @example
+ * interpolateParams("Min value is {{min}}", { kind: 'min', min: 5 })
+ * // Returns: "Min value is 5"
  */
-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>>;
-};
+declare function interpolateParams(message: string, error: ValidationError): string;
 
-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 };
+export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, DYNAMIC_FORM_LOGGER, DynamicForm, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FormClearEvent, FormResetEvent, GroupFieldComponent, LogLevel, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RowFieldComponent, SubmitEvent, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, dynamicTextToObservable, getArrayLength, groupFieldMapper, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withLogger };
+export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, LoggerFeatureOptions, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };