@ng-forge/dynamic-forms 0.1.2 → 0.2.0

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]>;
@@ -236,7 +236,7 @@ type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
  *
  * @public
  */
-type FieldComponent<T extends FieldDef<any>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
+type FieldComponent<T extends FieldDef<Record<string, unknown> | unknown>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
 
 /**
  * Re-export Angular's ValidationError for consistency
@@ -707,10 +707,10 @@ type NarrowField<T> = T extends {
 type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
 
 /**
- * Helper type to convert union to intersection
- * Note: `any` is necessary for distributive conditional types
+ * Helper type to convert union to intersection.
+ * Uses `U extends U` to trigger distributive conditional type behavior.
  */
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type UnionToIntersection<U> = (U extends U ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
  * Depth counter for recursion limiting (prevents infinite type instantiation)
  */
@@ -928,8 +928,8 @@ interface SchemaDefinition {
  * - 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`
+ * - Other fields: `ctx.fieldTreeOf(path)`
+ * - Current field tree: `ctx.fieldTree`
  *
  * **Return Types:**
  * - Single error: `{ kind: 'errorKind' }` for field-level validation
@@ -1083,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[]>;
 }
 /**
@@ -1180,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 Logger {
+    /**
+     * 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;
@@ -1189,6 +1216,8 @@ interface EvaluationContext<TValue = unknown> {
     fieldPath: string;
     /** Custom evaluation functions */
     customFunctions?: Record<string, (context: EvaluationContext) => unknown>;
+    /** Logger for diagnostic output */
+    logger: Logger;
     /** Allow additional properties for flexible expression evaluation */
     [key: string]: unknown;
 }
@@ -1852,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;
@@ -1924,7 +1956,10 @@ interface FieldTypeDefinition<T extends FieldDef<any> = any> {
     name: string;
     /** Field definition type marker (internal use) */
     _fieldDef?: T;
-    /** Function to load the component (supports lazy loading) */
+    /**
+     * Function to load the component (supports lazy loading)
+     * Returns a Promise that resolves to the component class or module with default export
+     */
     loadComponent?: () => Promise<any>;
     /** Mapper function that converts field definition to component bindings */
     mapper: MapperFn<T>;
@@ -1946,14 +1981,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.
@@ -2173,7 +2200,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;
@@ -2181,6 +2208,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. */
@@ -2281,6 +2309,20 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     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
  */
@@ -2291,9 +2333,11 @@ type ExtractFieldDef<T> = T extends FieldTypeDefinition<infer F> ? F : never;
 type FieldDefUnion<T extends FieldTypeDefinition[]> = ExtractFieldDef<T[number]>;
 /**
  * Infer form value type from field definitions
+ * Note: Full value type inference requires complex recursive type mapping.
+ * Using unknown as placeholder until full inference is implemented.
  */
-type InferFormValue<TFieldDefs extends FieldDef<any>[]> = {
-    [K in TFieldDefs[number]['key']]: any;
+type InferFormValue<TFieldDefs extends FieldDef<unknown>[]> = {
+    [K in TFieldDefs[number]['key']]: unknown;
 };
 /**
  * Provider result with type inference
@@ -2302,13 +2346,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 withLoggerConfig)
  * @returns Environment providers for dependency injection with type inference
  *
  * @example
@@ -2323,14 +2377,15 @@ type ProvideDynamicFormResult<T extends FieldTypeDefinition[]> = EnvironmentProv
  *
  * @example
  * ```typescript
- * // Route-level setup
- * const routes: Routes = [
- *   {
- *     path: 'form',
- *     component: FormComponent,
- *     providers: [provideDynamicForm(...withMaterialFields())]
- *   }
- * ];
+ * // Disable logging
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDynamicForm(
+ *       ...withMaterialFields(),
+ *       withLoggerConfig(false)
+ *     )
+ *   ]
+ * });
  * ```
  *
  * @example
@@ -2349,7 +2404,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
  */
@@ -2394,8 +2449,71 @@ type ExtractFormValue<T> = T extends {
  * { type: 'page', key: 'step1', fields: [...] }
  * ```
  */
+/**
+ * Built-in field types provided by the dynamic form library.
+ *
+ * Each field type is validated at compile time using satisfies, ensuring
+ * type safety of the mapper function while allowing the array to be typed
+ * as FieldTypeDefinition[] for consumer flexibility.
+ */
 declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
 
+/**
+ * Configure logging for dynamic forms.
+ *
+ * By default, logging is enabled (ConsoleLogger). Use this feature to disable logging
+ * or configure it conditionally.
+ *
+ * @example
+ * ```typescript
+ * // Disable logging
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withLoggerConfig(false)
+ * )
+ *
+ * // Conditional logging (e.g., only in dev mode)
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withLoggerConfig(() => isDevMode())
+ * )
+ * ```
+ *
+ * @param enabled - Whether logging is enabled. Can be a boolean or a function that returns a boolean. Defaults to true.
+ * @returns A DynamicFormFeature that configures logging
+ */
+declare function withLoggerConfig(enabled?: boolean | (() => boolean)): DynamicFormFeature<'logger'>;
+
+/**
+ * Injection token for the dynamic forms logger.
+ *
+ * Provided by provideDynamicForm() with ConsoleLogger as default.
+ * Override with withLoggerConfig(false) to disable logging.
+ */
+declare const DynamicFormLogger: InjectionToken<Logger>;
+
+/**
+ * Console-based logger implementation.
+ */
+declare class ConsoleLogger implements Logger {
+    private readonly prefix;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+
+/**
+ * No-operation logger implementation.
+ * All methods are no-ops - used in production by default.
+ */
+declare class NoopLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+
 interface FieldOption<T = unknown> {
     label: DynamicText;
     value: T;
@@ -2432,7 +2550,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.
  *
@@ -2460,8 +2578,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) */
@@ -2472,6 +2590,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?: Logger;
 }
 /**
  * Resolves the disabled state for a submit button.
@@ -2556,7 +2676,7 @@ interface BaseValueField<TProps, TValue> extends FieldDef<TProps>, FieldWithVali
 }
 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>>>;
+type ValueFieldComponent<T extends BaseValueField<Record<string, unknown> | unknown, unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
 
 interface BaseCheckedField<TProps> extends FieldDef<TProps>, FieldWithValidation {
     value?: boolean;
@@ -2569,222 +2689,10 @@ interface BaseCheckedField<TProps> extends FieldDef<TProps>, FieldWithValidation
 }
 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;
-}
-/**
- * Input types that produce string values
- */
-type StringInputType = Exclude<InputType, 'number'>;
-/**
- * Number input field with strict number value type.
- * When props.type is 'number', value must be number.
- * Props is REQUIRED and must include type: 'number'.
- */
-interface NumberInputField<TProps extends {
-    type?: string;
-} = InputProps> extends BaseValueField<TProps & {
-    type: 'number';
-}, number> {
-    type: 'input';
-    props: TProps & {
-        type: 'number';
-    };
-}
-/**
- * String input field with strict string value type.
- * When props.type is text/email/etc (or undefined), value must be string.
- * Props type cannot be 'number'.
- */
-interface StringInputField<TProps extends {
-    type?: string;
-} = InputProps> extends BaseValueField<TProps & {
-    type?: StringInputType;
-}, string> {
-    type: 'input';
-    props?: TProps & {
-        type?: StringInputType;
-    };
-}
-/**
- * Builds discriminated union where props.type determines value type.
- * - If props.type is 'number', only NumberInputField matches (value: number)
- * - If props.type is undefined/text/email/etc, only StringInputField matches (value: string)
- */
-type BuildInputFieldUnion<TProps extends {
-    type?: string;
-}> = NumberInputField<TProps> | StringInputField<TProps>;
-/**
- * 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;
-}
+type CheckedFieldComponent<T extends BaseCheckedField<Record<string, unknown> | unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
 
-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";
@@ -2922,7 +2830,7 @@ declare class EventBus {
      * eventBus.dispatch(CustomFormEvent);
      * ```
      */
-    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: any[]): void;
+    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
     /**
      * Subscribes to events of a specific type.
      *
@@ -2993,21 +2901,16 @@ interface ArrayItemContext {
 }
 
 /**
- * Maps a value field definition to component inputs.
+ * Base error class for all Dynamic Forms errors.
  *
- * 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
+ * This class centralizes the `[Dynamic Forms]` prefix, ensuring consistent
+ * error messaging across the library without requiring each error site to
+ * manually include the prefix.
  */
-declare function valueFieldMapper<TProps = unknown, TValue = unknown>(fieldDef: BaseValueField<TProps, TValue>): Signal<Record<string, unknown>>;
+declare class DynamicFormError extends Error {
+    private static readonly PREFIX;
+    constructor(message: string);
+}
 
 /**
  * Builds base input properties from a field definition.
@@ -3030,17 +2933,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.
  *
@@ -3088,31 +2980,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>
@@ -3124,65 +3001,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.
@@ -3231,6 +3049,7 @@ 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>;
@@ -3250,12 +3069,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;
@@ -3273,11 +3093,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>;
@@ -3314,12 +3129,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;
@@ -3343,143 +3159,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, ExtractField, 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, NarrowField, NarrowFields, 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, ConsoleLogger, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FormClearEvent, FormResetEvent, GroupFieldComponent, 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, withLoggerConfig };
+export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DynamicFormFieldRegistry, 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, Logger, 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 };