@ng-forge/dynamic-forms 0.3.0 → 0.4.0

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Provider, Injector, WritableSignal, Type } from '@angular/core';
 import { Mock } from 'vitest';
-import { Logger, FieldDef, FormConfig, DynamicForm, ValidationMessages, FieldSignalContext, RegisteredFieldTypes } from '@ng-forge/dynamic-forms';
+import { Logger, FieldDef, FormConfig, DynamicForm, ValidationMessages, FormOptions, FieldSignalContext, RegisteredFieldTypes } from '@ng-forge/dynamic-forms';
 import { ComponentFixture } from '@angular/core/testing';
 import { ValidationError, form, FieldTree } from '@angular/forms/signals';
 import { Observable } from 'rxjs';
@@ -174,8 +174,14 @@ interface TestFieldContextConfig<TModel extends Record<string, unknown> = Record
     defaultValues?: () => TModel;
     /**
      * Default validation messages for the form.
+     * Provided via DEFAULT_VALIDATION_MESSAGES injection token.
      */
     defaultValidationMessages?: ValidationMessages;
+    /**
+     * Form options for button disabled state defaults.
+     * Provided via FORM_OPTIONS injection token.
+     */
+    formOptions?: FormOptions;
     /**
      * Custom value signal. If provided, this will be used instead of creating a new one.
      */

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, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
+import { FieldTree, FieldContext, ValidationError as ValidationError$1, TreeValidationResult, 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, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
+import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, OnDestroy, InputSignal, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
 
 type WithInputSignals<T> = {
     readonly [K in keyof T]-?: Signal<T[K]>;
@@ -299,19 +299,151 @@ type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
 type FieldComponent<T extends FieldDef<unknown, FieldMeta>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
 
 /**
- * Re-export Angular's ValidationError for consistency
- * This replaces our custom ValidationError interface
+ * Field signal context - the "nervous system" of the dynamic form.
+ * Provided via FIELD_SIGNAL_CONTEXT injection token.
+ *
+ * Gives mappers and components access to form state, values, and configuration.
+ * Container fields (Group, Array) create scoped contexts with nested forms.
+ *
+ * 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.
+ *
+ * Note: Form-level configuration (defaultValidationMessages, formOptions, defaultProps)
+ * is provided via dedicated injection tokens (DEFAULT_VALIDATION_MESSAGES, FORM_OPTIONS,
+ * DEFAULT_PROPS) at the DynamicForm level and inherited by all children.
  */
-type ValidationError = ValidationError$1;
-interface ValidationMessages {
-    required?: DynamicText;
-    email?: DynamicText;
-    min?: DynamicText;
-    max?: DynamicText;
-    minLength?: DynamicText;
-    maxLength?: DynamicText;
-    pattern?: DynamicText;
-    [key: string]: DynamicText | undefined;
+interface FieldSignalContext<TModel extends Record<string, unknown> = Record<string, unknown>> {
+    injector: Injector;
+    value: WritableSignal<Partial<TModel> | undefined>;
+    defaultValues: () => TModel;
+    form: FieldTree<TModel>;
+    /** Current page validity signal for paged forms. Used by next button to determine disabled state. */
+    currentPageValid?: Signal<boolean>;
+}
+/**
+ * Array context for fields rendered within arrays.
+ * Provides position and parent array information for components inside array fields.
+ */
+interface ArrayContext {
+    /** The key of the parent array field. */
+    arrayKey: string;
+    /**
+     * The index of this item within the array.
+     * Uses linkedSignal to automatically update when items are added/removed,
+     * allowing index-dependent logic to react without component recreation.
+     */
+    index: Signal<number>;
+    /** The current form value for token resolution. */
+    formValue: unknown;
+    /** The array field definition. */
+    field: FieldDef<unknown>;
+}
+/**
+ * Mapper function that converts a field definition to component inputs.
+ *
+ * Mappers run within an injection context and can inject FIELD_SIGNAL_CONTEXT.
+ * Returns a Signal to enable reactive updates when dependencies change.
+ */
+type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string, unknown>>;
+
+/**
+ * Defines how a field type handles form values and data collection.
+ *
+ * - 'include': Field contributes to form values (default for input fields)
+ * - 'exclude': Field is excluded from form values (for display/layout fields)
+ * - 'flatten': Field's children are flattened to parent level (for container fields)
+ */
+type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
+/**
+ * Configuration interface for registering custom field types.
+ *
+ * Defines how a field type should be handled by the dynamic form system,
+ * including its component loading strategy and field-to-component mapping logic.
+ * Supports both eager-loaded and lazy-loaded components.
+ *
+ * @typeParam T - The field definition type this field type handles
+ *
+ * @example
+ * ```typescript
+ * const CustomInputType: FieldTypeDefinition<InputFieldDef> = {
+ *   name: 'custom-input',
+ *   loadComponent: () => import('./custom-input.component').then(m => m.CustomInputComponent),
+ *   mapper: customInputMapper
+ * };
+ *
+ * // Register with providers
+ * provideDynamicForm(CustomInputType)
+ * ```
+ */
+interface FieldTypeDefinition<T extends FieldDef<any> = any> {
+    /** Unique identifier for the field type */
+    name: string;
+    /** Field definition type marker (internal use) */
+    _fieldDef?: T;
+    /**
+     * Function to load the component (supports lazy loading).
+     * Returns a Promise that resolves to the component class or module with default export.
+     *
+     * Optional - omit for componentless fields (e.g., hidden fields) that only
+     * contribute to form values without rendering any UI.
+     */
+    loadComponent?: () => Promise<any>;
+    /**
+     * Mapper function that converts field definition to component bindings.
+     *
+     * Optional - omit for componentless fields (like hidden fields) that don't need
+     * input mapping. When omitted for componentless fields (no loadComponent), an empty
+     * signal is returned. When omitted for regular fields with a component, falls back
+     * to baseFieldMapper.
+     */
+    mapper?: MapperFn<T>;
+    /** How this field type handles form values and data collection (defaults to 'include') */
+    valueHandling?: ValueHandlingMode;
+    /**
+     * List of prop keys to forward to the meta object.
+     *
+     * Some props (like `type` for inputs, `rows`/`cols` for textareas) are actually
+     * native HTML attributes. Specifying them here causes them to be merged into
+     * the meta object before being passed to the component, ensuring they're applied
+     * via the meta tracking mechanism.
+     *
+     * Note: Meta values always take precedence over forwarded props.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   name: 'input',
+     *   propsToMeta: ['type'],
+     *   // ...
+     * }
+     * ```
+     */
+    propsToMeta?: string[];
+}
+/**
+ * Injection token for the global field type registry.
+ *
+ * Provides access to the map of registered field types throughout the application.
+ * The registry is populated by the provideDynamicForm function and used by
+ * field rendering components to resolve field types to their implementations.
+ *
+ * @example
+ * ```typescript
+ * constructor(@Inject(FIELD_REGISTRY) private registry: Map<string, FieldTypeDefinition>) {
+ *   const inputType = registry.get('input');
+ * }
+ * ```
+ */
+declare const FIELD_REGISTRY: InjectionToken<Map<string, FieldTypeDefinition<any>>>;
+
+/**
+ * Resolved field ready for rendering with ngComponentOutlet.
+ */
+interface ResolvedField {
+    key: string;
+    component: Type<unknown>;
+    injector: Injector;
+    inputs: Signal<Record<string, unknown>>;
 }
 
 /**
@@ -1393,6 +1525,22 @@ interface EvaluationContext<TValue = unknown> {
  */
 type CustomFunction = (context: EvaluationContext) => unknown;
 
+/**
+ * Re-export Angular's ValidationError for consistency
+ * This replaces our custom ValidationError interface
+ */
+type ValidationError = ValidationError$1;
+interface ValidationMessages {
+    required?: DynamicText;
+    email?: DynamicText;
+    min?: DynamicText;
+    max?: DynamicText;
+    minLength?: DynamicText;
+    maxLength?: DynamicText;
+    pattern?: DynamicText;
+    [key: string]: DynamicText | undefined;
+}
+
 /**
  * The result type for submission actions.
  * Can be either a Promise or an Observable.
@@ -1545,10 +1693,11 @@ interface SubmissionConfig<TValue = unknown> {
  *
  * @typeParam TFields - Array of registered field types available for this form
  * @typeParam TValue - The strongly-typed interface for form values
+ * @typeParam TProps - The type for form-level default props (library-specific)
  *
  * @public
  */
-interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>> {
+interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, TProps extends object = Record<string, unknown>> {
     /**
      * Array of field definitions that define the form structure.
      *
@@ -1659,6 +1808,32 @@ interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = Reg
      * ```
      */
     submission?: SubmissionConfig<TValue>;
+    /**
+     * Default props applied to all fields in the form.
+     *
+     * These props serve as defaults that can be overridden at the field level.
+     * Useful for setting consistent styling across the entire form (e.g., appearance,
+     * size, or other UI library-specific props).
+     *
+     * The cascade order is: Library config → Form defaultProps → Field props
+     * Each level can override the previous one.
+     *
+     * @example
+     * ```typescript
+     * // Material example
+     * const config: MatFormConfig = {
+     *   defaultProps: {
+     *     appearance: 'outline',
+     *     subscriptSizing: 'dynamic',
+     *   },
+     *   fields: [
+     *     { type: 'input', key: 'name', label: 'Name' },  // Uses defaultProps
+     *     { type: 'input', key: 'email', props: { appearance: 'fill' } },  // Override
+     *   ],
+     * };
+     * ```
+     */
+    defaultProps?: TProps;
 }
 /**
  * Signal forms adapter configuration for advanced form behavior.
@@ -2005,153 +2180,6 @@ interface NextButtonOptions {
     disableWhileSubmitting?: boolean;
 }
 
-/**
- * Field signal context - the "nervous system" of the dynamic form.
- * Provided via FIELD_SIGNAL_CONTEXT injection token.
- *
- * Gives mappers and components access to form state, values, and configuration.
- * Container fields (Group, Array) create scoped contexts with nested forms.
- *
- * 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 extends Record<string, unknown> = Record<string, unknown>> {
-    injector: Injector;
-    value: WritableSignal<Partial<TModel> | undefined>;
-    defaultValues: () => TModel;
-    form: FieldTree<TModel>;
-    defaultValidationMessages?: ValidationMessages;
-    /** Form-level options used by button mappers to determine disabled state defaults. */
-    formOptions?: FormOptions;
-    /** Current page validity signal for paged forms. Used by next button to determine disabled state. */
-    currentPageValid?: Signal<boolean>;
-}
-/**
- * Array context for fields rendered within arrays.
- * Provides position and parent array information for components inside array fields.
- */
-interface ArrayContext {
-    /** The key of the parent array field. */
-    arrayKey: string;
-    /**
-     * The index of this item within the array.
-     * Uses linkedSignal to automatically update when items are added/removed,
-     * allowing index-dependent logic to react without component recreation.
-     */
-    index: Signal<number>;
-    /** The current form value for token resolution. */
-    formValue: unknown;
-    /** The array field definition. */
-    field: FieldDef<unknown>;
-}
-/**
- * Mapper function that converts a field definition to component inputs.
- *
- * Mappers run within an injection context and can inject FIELD_SIGNAL_CONTEXT.
- * Returns a Signal to enable reactive updates when dependencies change.
- */
-type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string, unknown>>;
-
-/**
- * Defines how a field type handles form values and data collection.
- *
- * - 'include': Field contributes to form values (default for input fields)
- * - 'exclude': Field is excluded from form values (for display/layout fields)
- * - 'flatten': Field's children are flattened to parent level (for container fields)
- */
-type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
-/**
- * Configuration interface for registering custom field types.
- *
- * Defines how a field type should be handled by the dynamic form system,
- * including its component loading strategy and field-to-component mapping logic.
- * Supports both eager-loaded and lazy-loaded components.
- *
- * @typeParam T - The field definition type this field type handles
- *
- * @example
- * ```typescript
- * const CustomInputType: FieldTypeDefinition<InputFieldDef> = {
- *   name: 'custom-input',
- *   loadComponent: () => import('./custom-input.component').then(m => m.CustomInputComponent),
- *   mapper: customInputMapper
- * };
- *
- * // Register with providers
- * provideDynamicForm(CustomInputType)
- * ```
- */
-interface FieldTypeDefinition<T extends FieldDef<any> = any> {
-    /** Unique identifier for the field type */
-    name: string;
-    /** Field definition type marker (internal use) */
-    _fieldDef?: T;
-    /**
-     * Function to load the component (supports lazy loading).
-     * Returns a Promise that resolves to the component class or module with default export.
-     *
-     * Optional - omit for componentless fields (e.g., hidden fields) that only
-     * contribute to form values without rendering any UI.
-     */
-    loadComponent?: () => Promise<any>;
-    /**
-     * Mapper function that converts field definition to component bindings.
-     *
-     * Optional - omit for componentless fields (like hidden fields) that don't need
-     * input mapping. When omitted for componentless fields (no loadComponent), an empty
-     * signal is returned. When omitted for regular fields with a component, falls back
-     * to baseFieldMapper.
-     */
-    mapper?: MapperFn<T>;
-    /** How this field type handles form values and data collection (defaults to 'include') */
-    valueHandling?: ValueHandlingMode;
-    /**
-     * List of prop keys to forward to the meta object.
-     *
-     * Some props (like `type` for inputs, `rows`/`cols` for textareas) are actually
-     * native HTML attributes. Specifying them here causes them to be merged into
-     * the meta object before being passed to the component, ensuring they're applied
-     * via the meta tracking mechanism.
-     *
-     * Note: Meta values always take precedence over forwarded props.
-     *
-     * @example
-     * ```typescript
-     * {
-     *   name: 'input',
-     *   propsToMeta: ['type'],
-     *   // ...
-     * }
-     * ```
-     */
-    propsToMeta?: string[];
-}
-/**
- * Injection token for the global field type registry.
- *
- * Provides access to the map of registered field types throughout the application.
- * The registry is populated by the provideDynamicForm function and used by
- * field rendering components to resolve field types to their implementations.
- *
- * @example
- * ```typescript
- * constructor(@Inject(FIELD_REGISTRY) private registry: Map<string, FieldTypeDefinition>) {
- *   const inputType = registry.get('input');
- * }
- * ```
- */
-declare const FIELD_REGISTRY: InjectionToken<Map<string, FieldTypeDefinition<any>>>;
-
-/**
- * Resolved field ready for rendering with ngComponentOutlet.
- */
-interface ResolvedField {
-    key: string;
-    component: Type<unknown>;
-    injector: Injector;
-    inputs: Signal<Record<string, unknown>>;
-}
-
 /**
  * Form mode enumeration distinguishing between paged and non-paged forms
  */
@@ -2389,6 +2417,10 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
         nextButton?: _ng_forge_dynamic_forms.NextButtonOptions;
     }>;
     readonly fieldSignalContext: Signal<FieldSignalContext<TModel>>;
+    /**
+     * Injector for field components with FIELD_SIGNAL_CONTEXT.
+     * Other form-level tokens (DEFAULT_PROPS, etc.) are provided at component level.
+     */
     private readonly fieldInjector;
     readonly defaultValues: _angular_core.WritableSignal<TModel>;
     private readonly entity;
@@ -2731,6 +2763,82 @@ declare const FIELD_SIGNAL_CONTEXT: InjectionToken<FieldSignalContext<Record<str
  * ```
  */
 declare const ARRAY_CONTEXT: InjectionToken<ArrayContext>;
+/**
+ * Injection token for form-level default props.
+ *
+ * Default props are form-wide property defaults that are merged with field-level props.
+ * Field props take precedence over default props.
+ *
+ * Unlike FIELD_SIGNAL_CONTEXT which is re-provided by container components (Group, Array),
+ * DEFAULT_PROPS is provided ONCE at the DynamicForm level and inherited by all children
+ * via Angular's hierarchical injector.
+ *
+ * The token provides a Signal to enable reactivity - when config changes, mappers
+ * that read the signal inside their computed() will automatically update.
+ *
+ * @example
+ * ```typescript
+ * // In a mapper function
+ * const defaultPropsSignal = inject(DEFAULT_PROPS);
+ *
+ * return computed(() => {
+ *   const defaultProps = defaultPropsSignal?.();  // Read inside computed for reactivity
+ *   const baseInputs = buildBaseInputs(fieldDef, defaultProps);
+ *   // ...
+ * });
+ * ```
+ */
+declare const DEFAULT_PROPS: InjectionToken<Signal<Record<string, unknown> | undefined>>;
+/**
+ * Injection token for form-level default validation messages.
+ *
+ * Default validation messages act as fallbacks when fields have validation
+ * errors but no field-level `validationMessages` defined.
+ *
+ * Like DEFAULT_PROPS, this token is provided ONCE at the DynamicForm level
+ * and inherited by all children via Angular's hierarchical injector.
+ *
+ * The token provides a Signal to enable reactivity - when config changes, mappers
+ * that read the signal inside their computed() will automatically update.
+ *
+ * @example
+ * ```typescript
+ * // In a mapper or component
+ * const defaultMessagesSignal = inject(DEFAULT_VALIDATION_MESSAGES);
+ *
+ * return computed(() => {
+ *   const defaultMessages = defaultMessagesSignal?.();  // Read inside computed for reactivity
+ *   const message = defaultMessages?.required ?? 'Field is required';
+ *   // ...
+ * });
+ * ```
+ */
+declare const DEFAULT_VALIDATION_MESSAGES: InjectionToken<Signal<ValidationMessages | undefined>>;
+/**
+ * Injection token for form-level options.
+ *
+ * Form options control form-wide behavior including button disabled states.
+ * Used by button mappers to determine default disabled behavior.
+ *
+ * Like DEFAULT_PROPS, this token is provided ONCE at the DynamicForm level
+ * and inherited by all children via Angular's hierarchical injector.
+ *
+ * The token provides a Signal to enable reactivity - when config changes, mappers
+ * that read the signal inside their computed() will automatically update.
+ *
+ * @example
+ * ```typescript
+ * // In a button mapper
+ * const formOptionsSignal = inject(FORM_OPTIONS);
+ *
+ * return computed(() => {
+ *   const formOptions = formOptionsSignal?.();  // Read inside computed for reactivity
+ *   const disableWhenInvalid = formOptions?.submitButton?.disableWhenInvalid ?? true;
+ *   // ...
+ * });
+ * ```
+ */
+declare const FORM_OPTIONS: InjectionToken<Signal<FormOptions | undefined>>;
 
 /**
  * Context for resolving button disabled state.
@@ -3079,9 +3187,10 @@ declare class DynamicFormError extends Error {
  * Used by mappers to build the inputs record.
  *
  * @param fieldDef The field definition to extract properties from
+ * @param defaultProps Optional form-level default props to merge with field props
  * @returns Record of input names to values
  */
-declare function buildBaseInputs(fieldDef: FieldDef<unknown>): Record<string, unknown>;
+declare function buildBaseInputs(fieldDef: FieldDef<unknown>, defaultProps?: Record<string, unknown>): Record<string, unknown>;
 /**
  * Base field mapper that extracts common field properties into component inputs.
  *
@@ -3239,6 +3348,8 @@ declare class RowFieldComponent {
     private readonly logger;
     field: _angular_core.InputSignal<RowField<readonly _ng_forge_dynamic_forms.RowAllowedChildren[]>>;
     key: _angular_core.InputSignal<string>;
+    className: _angular_core.InputSignal<string | undefined>;
+    readonly hostClasses: _angular_core.Signal<string>;
     readonly disabled: _angular_core.Signal<boolean>;
     private readonly rawFieldRegistry;
     private readonly fieldsSource;
@@ -3246,7 +3357,7 @@ declare class RowFieldComponent {
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowFieldComponent, "div[row-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -3268,6 +3379,8 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly memoizedDefaultValues;
     field: _angular_core.InputSignal<GroupField<readonly _ng_forge_dynamic_forms.GroupAllowedChildren[]>>;
     key: _angular_core.InputSignal<string>;
+    className: _angular_core.InputSignal<string | undefined>;
+    readonly hostClasses: _angular_core.Signal<string>;
     private readonly rawFieldRegistry;
     private readonly formSetup;
     readonly defaultValues: _angular_core.WritableSignal<Record<string, unknown>>;
@@ -3290,7 +3403,7 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     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>;
+    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; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, { "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; }, never, never, true, never>;
 }
 
 /**
@@ -3325,6 +3438,8 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly logger;
     field: _angular_core.InputSignal<ArrayField<readonly _ng_forge_dynamic_forms.ArrayAllowedChildren[]>>;
     key: _angular_core.InputSignal<string>;
+    className: _angular_core.InputSignal<string | undefined>;
+    readonly hostClasses: _angular_core.Signal<string>;
     private readonly rawFieldRegistry;
     private readonly fieldTemplate;
     private readonly arrayFieldTrees;
@@ -3342,7 +3457,7 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     private addItem;
     private removeItem;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrayFieldComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayFieldComponent<any>, "array-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayFieldComponent<any>, "array-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -3390,5 +3505,98 @@ declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): O
  */
 declare function interpolateParams(message: string, error: ValidationError): string;
 
-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, applyMetaToElement, 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 };
+/**
+ * Registry service that maintains references to root form fields.
+ * This provides a type-safe way to access root form values from child fields
+ * without relying on internal Angular Forms API navigation.
+ *
+ * This service should be provided at the component level to ensure proper
+ * isolation between different form instances.
+ *
+ * IMPORTANT: This registry supports two registration patterns:
+ * 1. registerFormValueSignal() - Register the SOURCE signal BEFORE form creation
+ *    This allows logic functions to read form values during schema evaluation.
+ * 2. registerRootForm() - Register the FieldTree AFTER form creation
+ *    This provides access to the full form structure.
+ *
+ * For cross-field logic to work correctly, registerFormValueSignal() should be
+ * called BEFORE the form() call.
+ */
+declare class RootFormRegistryService {
+    private readonly _rootForms;
+    private readonly _formValueSignals;
+    private readonly formContexts;
+    /**
+     * Registers the form value signal BEFORE form creation.
+     *
+     * This is the recommended pattern for cross-field logic:
+     * 1. Create the formValue signal
+     * 2. Register it with registerFormValueSignal()
+     * 3. Create the form with form(formValue, schema(...))
+     *
+     * This allows logic functions to access form values during schema evaluation.
+     */
+    registerFormValueSignal(valueSignal: Signal<Record<string, unknown>>, formId?: string): void;
+    /**
+     * Gets the registered form value signal by id.
+     *
+     * This allows direct access to the source signal, which can be read
+     * reactively to get form values.
+     */
+    getFormValueSignal(formId?: string): Signal<Record<string, unknown>> | undefined;
+    /**
+     * Registers a root form field with an optional identifier.
+     * If no id is provided, uses 'default' as the key.
+     *
+     * This triggers reactive updates for any computed signals that
+     * depend on getRootForm().
+     */
+    registerRootForm(rootField: FieldTree<unknown>, formId?: string): void;
+    /**
+     * Gets a registered root form field by id.
+     *
+     * IMPORTANT: This method reads from a signal, which means any computed
+     * signal that calls this method will automatically re-evaluate when
+     * the form is registered or updated.
+     */
+    getRootForm(formId?: string): FieldTree<unknown> | undefined;
+    /**
+     * Gets the form value, preferring the direct signal if available.
+     *
+     * This method tries in order:
+     * 1. Form value signal (if registered) - reads directly from source signal
+     * 2. Root form's .value() (if registered) - reads from FieldTree
+     * 3. Returns empty object if nothing is registered
+     *
+     * Reading from signals creates reactive dependencies, so computeds will
+     * re-evaluate when form values change.
+     */
+    getFormValue(formId?: string): Record<string, unknown>;
+    /**
+     * Registers form context (field paths and metadata) for a specific form.
+     * This can be used to store additional context information.
+     */
+    registerFormContext(context: Record<string, unknown>, formId?: string): void;
+    /**
+     * Gets form context by id.
+     */
+    getFormContext(formId?: string): Record<string, unknown>;
+    /**
+     * Unregisters a form and its context.
+     * This should be called when a form component is destroyed to prevent memory leaks.
+     */
+    unregisterForm(formId?: string): void;
+    /**
+     * Gets all registered form IDs.
+     */
+    getRegisteredFormIds(): string[];
+    /**
+     * Clears all registered forms. Useful for testing.
+     */
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RootFormRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RootFormRegistryService>;
+}
+
+export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RootFormRegistryService, RowFieldComponent, SubmitEvent, applyMetaToElement, 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, FieldMeta, 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 };