@ng-forge/dynamic-forms 0.10.0-next.3 → 1.0.0-rc.1

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

@@ -1,1919 +1,14 @@
 import * as rxjs from 'rxjs';
-import { Observable } from 'rxjs';
 import * as _angular_core from '@angular/core';
-import { Signal, Type, ResourceRef, ViewContainerRef, InjectionToken, Injector, WritableSignal, EnvironmentInjector, Provider, EnvironmentProviders, TemplateRef, Resource, PipeTransform } from '@angular/core';
-import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
-import * as _angular_forms_signals from '@angular/forms/signals';
-import { FieldContext, TreeValidationResult, ValidationError as ValidationError$1, FieldTree, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
-import { FormSchema } from '@ng-forge/dynamic-forms/schema';
-import * as _angular_forms from '@angular/forms';
-
-type DynamicText = string | Observable<string> | Signal<string>;
-
-/** Generic reactive value — a static value, an Angular Signal, or an RxJS Observable. */
-type DynamicValue<T> = T | Signal<T> | Observable<T>;
-
-/** Universal addon slot names supported by every adapter. */
-type CommonAddonSlot = 'prefix' | 'suffix';
-/** Module-augmentable registry of adapter-specific addon slot names. */
-interface DynamicFormAddonSlotRegistry {
-}
-/**
- * Union of every valid addon slot — universal slots plus any registered via
- * {@link DynamicFormAddonSlotRegistry} module augmentation.
- */
-type AddonSlot = CommonAddonSlot | keyof DynamicFormAddonSlotRegistry;
-
-/** Base shape every addon kind extends. */
-interface BaseAddon<TSlot extends AddonSlot = AddonSlot> {
-    /** Slot to render this addon in. */
-    readonly slot: TSlot;
-    /** CSS class applied to the addon host element. */
-    readonly className?: string;
-    /** Reactive visibility — when `true`, the addon is removed from layout. */
-    readonly hidden?: DynamicValue<boolean>;
-    /** Reactive disabled state — primarily relevant for interactive kinds. */
-    readonly disabled?: DynamicValue<boolean>;
-}
-/** Module-augmentable registry of addon kinds. */
-interface DynamicFormAddonRegistry {
-    text: TextAddon;
-    template: TemplateAddon;
-    component: ComponentAddon;
-}
-/** Union of every registered addon shape. */
-type AnyAddon = DynamicFormAddonRegistry[keyof DynamicFormAddonRegistry];
-/** Renders text content inline. */
-interface TextAddon extends BaseAddon {
-    readonly kind: 'text';
-    readonly text: DynamicText;
-}
-/** Renders a named `<ng-template>` projected into the host `<df-dynamic-form>`. */
-interface TemplateAddon extends BaseAddon {
-    readonly kind: 'template';
-    readonly templateKey: string;
-}
-/**
- * Renders an arbitrary Angular component as the addon body.
- *
- * @codeOnly The `component` loader is a function and cannot survive
- * `JSON.stringify`/`parse`. The lenient validator drops this kind when the
- * config originated from JSON (set via `sanitizeFormConfig({ source: 'json' })`).
- */
-interface ComponentAddon extends BaseAddon {
-    readonly kind: 'component';
-    readonly component: () => Promise<Type<unknown> | {
-        default: Type<unknown>;
-    }>;
-    readonly inputs?: Record<string, unknown>;
-}
-
-type WithInputSignals<T> = {
-    readonly [K in keyof T]-?: Signal<T[K]>;
-};
-
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
-/**
- * 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;
-}
-
-/**
- * Shared shape for DI-scoped warning trackers that dedupe log output.
- *
- * @internal
- */
-interface WarningTracker {
-    warnedKeys: Set<string>;
-}
-
-/** Represents the state information of a single form field. */
-interface FieldStateInfo {
-    readonly touched: boolean;
-    readonly dirty: boolean;
-    /** Convenience property: equivalent to `!dirty` */
-    readonly pristine: boolean;
-    readonly valid: boolean;
-    readonly invalid: boolean;
-    readonly pending: boolean;
-    /** Whether the field is currently hidden. */
-    readonly hidden: boolean;
-    /** Whether the field is currently readonly. */
-    readonly readonly: boolean;
-    /** Whether the field is currently disabled. */
-    readonly disabled: boolean;
-}
-/** Map of field keys to their state information. */
-type FormFieldStateMap = Record<string, FieldStateInfo | undefined>;
-/** Field state context for the current field being evaluated. */
-type FieldStateContext = FieldStateInfo;
-
-interface EvaluationContext<TValue = unknown, TFormValue extends Record<string, unknown> = any> {
-    /** Current field value */
-    fieldValue: TValue;
-    /** Form value for the current evaluation scope. */
-    formValue: TFormValue;
-    /** Field path for relative references */
-    fieldPath: string;
-    /** Custom evaluation functions */
-    customFunctions?: Record<string, (context: EvaluationContext) => unknown>;
-    /** Logger for diagnostic output */
-    logger: Logger;
-    /**
-     * Value of the field's nearest parent **group** (or array item, when the
-     * field has no inner group above the array boundary).
-     */
-    groupValue?: unknown;
-    /** Root form value when inside an array context. */
-    rootFormValue?: Record<string, unknown>;
-    /** Current array index when inside an array derivation. */
-    arrayIndex?: number;
-    /** Path to the array field when inside an array derivation. */
-    arrayPath?: string;
-    /** External data signals resolved to their current values. */
-    externalData?: Record<string, unknown>;
-    /**
-     * DI-scoped tracker for deprecation warnings.
-     * Used by the condition evaluator to deduplicate deprecation warnings.
-     */
-    deprecationTracker?: WarningTracker;
-    /** State of the current field being evaluated. */
-    fieldState?: FieldStateContext;
-    /** State of all fields in the form, keyed by field key. */
-    formFieldState?: FormFieldStateMap;
-    /** Allow additional properties for flexible expression evaluation */
-    [key: string]: unknown;
-}
-
-/** Custom function signature for conditional expressions */
-type CustomFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => unknown;
-
-/** Async function for derivations — returns any value. */
-type AsyncDerivationFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<unknown> | Observable<unknown>;
-/** Async function for conditions — returns boolean. */
-type AsyncConditionFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<boolean> | Observable<boolean>;
-
-/** Configuration for an HTTP request used by declarative HTTP validators, derivations, and conditions. */
-interface HttpRequestConfig {
-    /** URL to send the request to */
-    url: string;
-    /** HTTP method. Defaults to 'GET' */
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    /**
-     * URL path parameters. Keys correspond to `:key` placeholders in the URL.
-     * Values are expressions evaluated by ExpressionParser against the current EvaluationContext.
-     */
-    params?: Record<string, string>;
-    /**
-     * Query parameters appended to the URL.
-     * Values are expressions evaluated by ExpressionParser against the current EvaluationContext.
-     */
-    queryParams?: Record<string, string>;
-    /** Request body (for POST/PUT/PATCH) */
-    body?: Record<string, unknown>;
-    /**
-     * When true, top-level string values in `body` are treated as expressions
-     * and evaluated by ExpressionParser (shallow only — nested objects are passed through as-is).
-     */
-    evaluateBodyExpressions?: boolean;
-    /** HTTP headers to include in the request */
-    headers?: Record<string, string>;
-}
-
-/** Comparison operators for field value and form value conditions. */
-type ComparisonOperator = 'equals' | 'notEquals' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual' | 'contains' | 'startsWith' | 'endsWith' | 'matches';
-/** Condition that compares a specific field's value against an expected value. */
-interface FieldValueCondition {
-    type: 'fieldValue';
-    /** Path to the field whose value to compare */
-    fieldPath: string;
-    /** Comparison operator */
-    operator: ComparisonOperator;
-    /** Value to compare against */
-    value?: unknown;
-}
-/** Condition that invokes a custom function. */
-type CustomCondition = {
-    type: 'custom';
-    /** Name of the registered custom function to invoke */
-    functionName: string;
-    /** Inline form is forbidden when `functionName` is set */
-    fn?: never;
-} | {
-    type: 'custom';
-    /** Inline custom function. Mutually exclusive with `functionName`. */
-    fn: CustomFunction;
-    /** Registered form is forbidden when `fn` is set */
-    functionName?: never;
-};
-/** Condition that evaluates a JavaScript expression using the secure AST-based parser. */
-interface JavascriptCondition {
-    type: 'javascript';
-    /** JavaScript expression string to evaluate */
-    expression: string;
-}
-/** Condition that evaluates based on an HTTP response from a remote server. */
-interface HttpCondition {
-    type: 'http';
-    /** HTTP request configuration */
-    http: HttpRequestConfig;
-    /**
-     * Expression to extract boolean from response (scope: `{ response }`).
-     * e.g. `'response.allowed'`, `'response.permissions.canEdit'`
-     * When omitted, the entire response is coerced to boolean: `!!response`
-     */
-    responseExpression?: string;
-    /**
-     * Value to return while the HTTP request is in-flight.
-     *
-     * @default false
-     */
-    pendingValue?: boolean;
-    /** Cache duration in ms for HTTP responses. @default 30000 */
-    cacheDurationMs?: number;
-    /**
-     * Debounce time in milliseconds for re-evaluation when dependent form values change.
-     *
-     * @default 300
-     */
-    debounceMs?: number;
-}
-/**
- * Shared fields for both branches of {@link AsyncCondition}.
- *
- * @internal
- */
-interface AsyncConditionBase {
-    type: 'async';
-    /**
-     * Value to return while async resolution is pending.
-     *
-     * @default false
-     */
-    pendingValue?: boolean;
-    /**
-     * Debounce ms for re-evaluation.
-     *
-     * @default 300
-     */
-    debounceMs?: number;
-}
-/** Condition that resolves asynchronously via a custom function. */
-type AsyncCondition = (AsyncConditionBase & {
-    /** Name of the registered async condition function */
-    asyncFunctionName: string;
-    /** Inline form is forbidden when `asyncFunctionName` is set */
-    asyncFn?: never;
-}) | (AsyncConditionBase & {
-    /** Inline async condition function. Mutually exclusive with `asyncFunctionName`. */
-    asyncFn: AsyncConditionFunction;
-    /** Registered form is forbidden when `asyncFn` is set */
-    asyncFunctionName?: never;
-});
-/** Logical AND — all sub-conditions must be true. */
-interface AndCondition {
-    type: 'and';
-    /** Sub-conditions that must all evaluate to true */
-    conditions: ConditionalExpression[];
-}
-/** Logical OR — at least one sub-condition must be true. */
-interface OrCondition {
-    type: 'or';
-    /** Sub-conditions where at least one must evaluate to true */
-    conditions: ConditionalExpression[];
-}
-/** Discriminated union of all conditional expression types. */
-type ConditionalExpression = FieldValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
-
-/**
- * Logic configuration for container fields (page, group, row, array).
- * Containers only support the 'hidden' logic type since they are layout containers,
- * not form controls (they can't be readonly, disabled, or required).
- */
-interface ContainerLogicConfig {
-    /** Only 'hidden' is supported for container fields */
-    type: 'hidden';
-    /**
-     * Condition that determines when this container is hidden.
-     * Can be a boolean or a conditional expression evaluated against form values.
-     */
-    condition: ConditionalExpression | boolean;
-}
-
-/**
- * Row field interface for creating horizontal layouts.
- * A row is a synthetic field type that resolves to a Container at runtime,
- * with a synthesized `{ type: 'row' }` wrapper applied for layout. The row
- * itself does not hold a value — its children flatten into the parent form.
- */
-interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowAllowedChildren[]> extends FieldDef<never> {
-    type: 'row';
-    /** Child definitions to render within this row */
-    readonly fields: TFields;
-    /** Row fields do not have a label property * */
-    readonly label?: never;
-    /** Rows do not support meta - they have no native form element * */
-    readonly meta?: never;
-    /**
-     * Logic configurations for conditional row visibility.
-     * Only 'hidden' type logic is supported for rows.
-     */
-    readonly logic?: ContainerLogicConfig[];
-}
-/** Type guard for RowField with proper type narrowing */
-declare function isRowField(field: FieldDef<any>): field is RowField;
-
-/**
- * Group field interface for creating logical field groupings that map to object values
- * Groups create nested form structures where child field values are collected into an object
- * This is a programmatic grouping only - users cannot customize this field type
- */
-interface GroupField<TFields extends readonly GroupAllowedChildren[] = readonly GroupAllowedChildren[]> extends FieldDef<never> {
-    type: 'group';
-    readonly fields: TFields;
-    /** Groups do not have a label property - they are logical containers only * */
-    readonly label?: never;
-    /** Groups do not support meta - they have no native form element * */
-    readonly meta?: never;
-    /**
-     * Logic configurations for conditional group visibility.
-     * Only 'hidden' type logic is supported for groups.
-     */
-    readonly logic?: ContainerLogicConfig[];
-}
-/** Type guard for GroupField with proper type narrowing */
-declare function isGroupField(field: FieldDef<any>): field is GroupField;
-
-/**
- * Page field interface for creating top-level page layouts
- * This is a special field type that contains other field definitions
- * The page itself doesn't have a value - it's a layout container like row
- * Pages can only be used at the top level and cannot be nested
- * This is a programmatic field type only - users cannot customize this field type
- */
-interface PageField<TFields extends readonly PageAllowedChildren[] = PageAllowedChildren[]> extends FieldDef<never> {
-    type: 'page';
-    /** Child field definitions to render within this page */
-    readonly fields: TFields;
-    /** Page fields do not have a label property * */
-    readonly label?: never;
-    /** Pages do not support meta - they have no native form element * */
-    readonly meta?: never;
-    /**
-     * Logic configurations for conditional page visibility.
-     * Only 'hidden' type logic is supported for pages.
-     */
-    readonly logic?: ContainerLogicConfig[];
-}
-/** Type guard for PageField with proper type narrowing */
-declare function isPageField(field: FieldDef<unknown>): field is PageField;
-
-/**
- * Helper type to convert union to intersection.
- * Uses `U extends U` to trigger distributive conditional type behavior.
- */
-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) */
-type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-/**
- * Widens literal types to their primitive equivalents, recursively for objects and arrays.
- * This prevents `as const` from over-narrowing types like `''` to literal `''` instead of `string`.
- */
-type Widen<T, D extends number = 5> = [D] extends [never] ? T : T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer U)[] ? Widen<U, Depth[D]>[] : T extends Record<string, unknown> ? {
-    -readonly [K in keyof T]: Widen<T[K], Depth[D]>;
-} : T;
-/**
- * Resolves the "underlying" non-null value type for a field, based on its `type`
- * discriminator and (where it matters) its `value` literal. Used when we need a
- * base type independent of whether the literal happens to be `null` — i.e., when
- * computing the nullable widening for `value: null, nullable: true`.
- */
-type ResolveBaseValueType<T, V> = T extends {
-    type: 'slider';
-} ? number : T extends {
-    type: 'input';
-    props: {
-        type: 'number';
-    };
-} ? number : T extends {
-    type: 'checkbox' | 'toggle';
-} ? boolean : [V] extends [null] ? string : Widen<V>;
-/**
- * Infer value type based on field type, value literal, and the `nullable` flag.
- * - Slider fields: always number
- * - Input fields with props.type: 'number': number
- * - Checkbox / toggle fields: always boolean
- * - Other fields: widen the literal value type (default to string when value is null)
- * - When `nullable: true` is declared, widens the result to `T | null`.
- */
-type InferValueType<T, V> = T extends {
-    nullable: true;
-} ? ResolveBaseValueType<T, V> | null : ResolveBaseValueType<T, V>;
-/**
- * Make type optional if field is not required.
- * Hidden fields are never optional since they require a value property.
- */
-type MaybeOptional<T, V> = T extends {
-    type: 'hidden';
-} ? V : T extends {
-    required: true;
-} ? V : V | undefined;
-/**
- * Infers the value type from a single template field (for primitive arrays).
- * Mirrors InferValueType logic: slider → number, input[number] → number,
- * checkbox/toggle → boolean, else widen `value` (string fallback). Widens to
- * `T | null` when `nullable: true` is declared on the template field.
- */
-type InferSingleTemplateValueBase<T, D extends number> = T extends {
-    type: 'slider';
-} ? number : T extends {
-    type: 'input';
-    props: {
-        type: 'number';
-    };
-} ? number : T extends {
-    type: 'checkbox' | 'toggle';
-} ? boolean : T extends {
-    value: infer V;
-} ? [V] extends [null] ? string : Widen<V, Depth[D]> : string;
-type InferSingleTemplateValue<T, D extends number> = T extends {
-    nullable: true;
-} ? InferSingleTemplateValueBase<T, D> | null : InferSingleTemplateValueBase<T, D>;
-/**
- * Infers the value type for an array field.
- * Handles four cases:
- * 1. Simplified array with template + value → infer item type from value
- * 2. Simplified array with array template (no value) → infer object type from template fields
- * 3. Simplified array with single-field template (no value) → infer primitive type from template field
- * 4. Full-API array with fields → infer from children
- */
-type InferArrayValue<T, D extends number> = T extends {
-    template: unknown;
-    value: readonly (infer Item)[];
-} ? Widen<Item>[] : T extends {
-    template: infer TArr;
-} ? TArr extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<[...TArr], Depth[D]>[] : InferSingleTemplateValue<TArr, D>[] : T extends {
-    fields: infer F;
-} ? F extends RegisteredFieldTypes[] ? InferFormValueWithDepth<F, Depth[D]>[] : unknown[] : unknown[];
-/** Process a single field and determine its contribution to the form value type */
-type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string, unknown> : 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 F;
-} ? K extends string ? F extends RegisteredFieldTypes[] ? {
-    [P in K]: InferFormValueWithDepth<F, Depth[D]>;
-} : {
-    [P in K]: Record<string, unknown>;
-} : never : T extends {
-    type: 'array';
-    key: infer K;
-} ? K extends string ? {
-    [P in K]: InferArrayValue<T, D>;
-} : never : T extends {
-    type: 'text';
-} ? never : T extends {
-    type: 'submit' | 'button' | 'next' | 'previous' | 'addArrayItem' | 'removeArrayItem';
-} ? never : T extends {
-    key: infer K;
-    value: infer V;
-} ? K extends string ? {
-    [P in K]: MaybeOptional<T, InferValueType<T, V>>;
-} : never : T extends {
-    key: infer K;
-} ? K extends string ? {
-    [P in K]: MaybeOptional<T, T extends {
-        nullable: true;
-    } ? string | null : string>;
-} : never : never;
-/** Internal helper with depth tracking */
-type InferFormValueWithDepth<T extends RegisteredFieldTypes[], D extends number = 5> = UnionToIntersection<ProcessField<T[number], D>>;
-/** 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.
- */
-type InferFormValue$1<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<ExtractFields<T> extends RegisteredFieldTypes[] ? ExtractFields<T> : [...ExtractFields<T>], 5> : never;
-
-/**
- * Custom validator function signature using Angular's public FieldContext API
- *
- * @template TValue The type of value stored in the field being validated
- */
-type CustomValidator<TValue = unknown> = (ctx: FieldContext<TValue>, params?: Record<string, unknown>) => ValidationError$1 | ValidationError$1[] | null;
-/**
- * Async custom validator configuration using Angular's resource-based API
- *
- * @template TValue The type of value stored in the field being validated
- * @template TParams The type of params passed to the resource
- * @template TResult The type of result returned by the resource
- */
-interface AsyncCustomValidator<TValue = unknown, TParams = unknown, TResult = unknown> {
-    /**
-     * Function that receives field context and returns resource params.
-     * Params will be tracked as a signal and trigger resource reload when changed.
-     */
-    readonly params: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => TParams;
-    /**
-     * Function that creates a ResourceRef from the params signal.
-     * The resource will be automatically managed by Angular's lifecycle.
-     */
-    readonly factory: (params: Signal<TParams | undefined>) => ResourceRef<TResult | undefined>;
-    /**
-     * Optional function to map successful resource result to validation errors.
-     * Return null if validation passes, or ValidationError/ValidationError[] if validation fails.
-     */
-    readonly onSuccess?: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
-    /**
-     * Optional error handler for resource errors (network failures, etc.).
-     * Return null to ignore the error, or ValidationError to display it to the user.
-     */
-    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
-}
-/** HTTP request configuration for validateHttp API */
-interface HttpResourceRequest {
-    url: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    body?: unknown;
-    headers?: Record<string, string | string[]>;
-}
-/**
- * HTTP-based validator configuration for Angular's validateHttp API
- *
- * @template TValue The type of value stored in the field being validated
- * @template TResult The type of HTTP response
- */
-interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
-    /**
-     * Function that returns the HTTP request configuration.
-     * Can return:
-     * - `undefined` to skip validation (e.g., if field is empty)
-     * - `string` for simple GET requests (just the URL)
-     * - `HttpResourceRequest` for full control (method, body, headers)
-     */
-    readonly request: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => string | HttpResourceRequest | undefined;
-    /** REQUIRED function to map successful HTTP response to validation errors. */
-    readonly onSuccess: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
-    /**
-     * Optional error handler for HTTP errors (network failures, 4xx/5xx status codes).
-     * Return null to ignore the error, or ValidationError to display it to the user.
-     */
-    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
-}
-
-/** Mapping configuration for interpreting HTTP responses as validation results. */
-interface HttpValidationResponseMapping {
-    /** Expression evaluated with scope `{ response }`. Must evaluate to `true` (strict boolean) to be valid. */
-    validWhen: string;
-    /** Error kind returned when validation fails — maps to field-level `validationMessages` */
-    errorKind: string;
-    /**
-     * Parameters to include in the validation error for message interpolation.
-     * Map of parameter names to expressions evaluated against `{ response }`.
-     */
-    errorParams?: Record<string, string>;
-}
-
-/** Base configuration shared by all validators */
-interface BaseValidatorConfig {
-    /** Conditional logic for when validator applies */
-    when?: ConditionalExpression;
-}
-/** Built-in validator configuration (required, email, min, max, etc.) */
-interface BuiltInValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
-    /** Static value for the validator (e.g., min value, pattern) */
-    value?: number | string | RegExp;
-    /** Dynamic value expression that evaluates to validator parameter */
-    expression?: string;
-}
-/**
- * Custom validator configuration using Angular's public FieldContext API.
- * Returns ValidationError | ValidationError[] | null synchronously.
- */
-interface CustomValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'custom';
-    /** Name of registered validator function (function-based pattern) */
-    functionName?: string;
-    /**
-     * Inline custom validator (code-only authoring).
-     * Mutually exclusive with `functionName`. NOT JSON-serializable.
-     */
-    fn?: CustomValidator;
-    /** Optional parameters to pass to validator function */
-    params?: Record<string, unknown>;
-    /** JavaScript expression to evaluate (expression-based pattern) */
-    expression?: string;
-    /** Error kind for expression-based validators - links to validationMessages */
-    kind?: string;
-    /**
-     * Parameters to include in error object for message interpolation (expression-based pattern)
-     * Map of parameter names to expressions that will be evaluated in the same context as the validation expression
-     */
-    errorParams?: Record<string, string>;
-}
-/**
- * Shared fields for both branches of {@link AsyncValidatorConfig}.
- *
- * @internal
- */
-interface AsyncValidatorConfigShared extends BaseValidatorConfig {
-    /** Validator type identifier. */
-    type: 'async';
-    /** Optional parameters to pass to validator function */
-    params?: Record<string, unknown>;
-}
-/**
- * Async custom validator configuration using Angular's `validateAsync` API.
- * Returns Observable<ValidationError | ValidationError[] | null>.
- */
-type AsyncValidatorConfig = (AsyncValidatorConfigShared & {
-    /** Name of registered async validator function */
-    functionName: string;
-    /** Inline form is forbidden when `functionName` is set */
-    fn?: never;
-}) | (AsyncValidatorConfigShared & {
-    /** Inline async validator. Mutually exclusive with `functionName`. */
-    fn: AsyncCustomValidator;
-    /** Registered form is forbidden when `fn` is set */
-    functionName?: never;
-});
-/**
- * Shared fields for both branches of {@link FunctionHttpValidatorConfig}.
- *
- * @internal
- */
-interface FunctionHttpValidatorConfigShared extends BaseValidatorConfig {
-    /** Validator type identifier. */
-    type: 'http';
-    /** Optional parameters to pass to HTTP validator */
-    params?: Record<string, unknown>;
-}
-/** Function-based HTTP validator configuration. Uses Angular's `validateHttp` API. */
-type FunctionHttpValidatorConfig = (FunctionHttpValidatorConfigShared & {
-    /** Name of registered HTTP validator configuration */
-    functionName: string;
-    /** Inline form is forbidden when `functionName` is set */
-    fn?: never;
-}) | (FunctionHttpValidatorConfigShared & {
-    /** Inline HTTP validator. Mutually exclusive with `functionName`. */
-    fn: HttpCustomValidator;
-    /** Registered form is forbidden when `fn` is set */
-    functionName?: never;
-});
-/** Declarative HTTP validator configuration — fully JSON-serializable, no function registration required. */
-interface DeclarativeHttpValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'http';
-    /** HTTP request configuration with expression-based query params and body */
-    http: HttpRequestConfig;
-    /** Mapping that interprets the HTTP response as a validation result */
-    responseMapping: HttpValidationResponseMapping;
-}
-/**
- * Configuration for signal forms validator functions that can be serialized from API.
- * Discriminated union type for type-safe validator configuration.
- */
-type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig;
-
-/** Special form-state conditions for button disabled logic. */
-type FormStateCondition = 
-/** True when form.valid() === false */
-'formInvalid'
-/** True when form.submitting() === true */
- | 'formSubmitting'
-/** True when fields on the current page are invalid (for paged forms) */
- | 'pageInvalid';
-/** Logic type for controlling field state (hidden, readonly, disabled, required). */
-type StateLogicType = 'hidden' | 'readonly' | 'disabled' | 'required';
-/**
- * Base configuration for conditional field state logic.
- *
- * @internal
- */
-interface BaseStateLogicConfig {
-    /** Logic type identifier for field state. */
-    type: StateLogicType;
-    /** Condition that determines when this logic applies. */
-    condition: ConditionalExpression | boolean | FormStateCondition;
-}
-/**
- * State logic that evaluates immediately on change (default).
- *
- * @internal
- */
-interface ImmediateStateLogicConfig extends BaseStateLogicConfig {
-    /**
-     * Trigger for immediate evaluation.
-     *
-     * @default 'onChange'
-     */
-    trigger?: 'onChange';
-    /** Not allowed for onChange trigger */
-    debounceMs?: never;
-}
-/**
- * State logic that evaluates after a debounce period.
- *
- * @internal
- */
-interface DebouncedStateLogicConfig extends BaseStateLogicConfig {
-    /**
-     * Trigger for debounced evaluation.
-     * Evaluates after the value has stabilized for the debounce duration.
-     */
-    trigger: 'debounced';
-    /**
-     * Debounce duration in milliseconds.
-     *
-     * @default 500
-     */
-    debounceMs?: number;
-}
-/** Configuration for conditional field state logic. */
-type StateLogicConfig = ImmediateStateLogicConfig | DebouncedStateLogicConfig;
-/**
- * Shared fields that appear on all derivation logic config variants.
- *
- * @internal
- */
-interface SharedDerivationFields {
-    /** Logic type identifier for value derivation. */
-    type: 'derivation';
-    /** Target property name for property derivation. */
-    targetProperty?: string;
-    /** Optional name for this derivation for debugging purposes. */
-    debugName?: string;
-    /** Condition that determines when this derivation applies. */
-    condition?: ConditionalExpression | boolean;
-    /**
-     * When true, the derivation stops running after the user manually
-     * edits the target field.
-     */
-    stopOnUserOverride?: boolean;
-    /**
-     * When true (and `stopOnUserOverride` is also true), clears the
-     * user-override flag when any dependency of this derivation changes,
-     * allowing the derivation to run again.
-     */
-    reEngageOnDependencyChange?: boolean;
-}
-/**
- * Trigger variants for derivation timing.
- *
- * @internal
- */
-type ImmediateDerivationTrigger = {
-    trigger?: 'onChange';
-    debounceMs?: never;
-};
-type DebouncedDerivationTrigger = {
-    trigger: 'debounced';
-    debounceMs?: number;
-};
-/**
- * Base for HTTP derivations. `source: 'http'` is required.
- * TypeScript enforces `dependsOn` and `responseExpression` at the type level.
- *
- * @internal
- */
-interface HttpDerivationBase extends SharedDerivationFields {
-    /** Identifies this derivation as HTTP-driven. */
-    source: 'http';
-    /** Forbidden on HTTP source */
-    fn?: never;
-    /** Forbidden on HTTP source */
-    asyncFn?: never;
-    /** HTTP request configuration for server-driven derivations. */
-    http: HttpRequestConfig;
-    /**
-     * Explicit field dependencies. Required for HTTP derivations to prevent
-     * wildcard triggering on every keystroke.
-     */
-    dependsOn: string[];
-    /** Expression to extract the derived value from the HTTP response. */
-    responseExpression: string;
-    value?: never;
-    expression?: never;
-    functionName?: never;
-    asyncFunctionName?: never;
-}
-/**
- * Shared fields for both branches of {@link AsyncFunctionDerivationBase}.
- *
- * @internal
- */
-interface AsyncFunctionDerivationShared extends SharedDerivationFields {
-    /** Identifies this derivation as async-function-driven. */
-    source: 'asyncFunction';
-    /** Forbidden on asyncFunction source */
-    fn?: never;
-    /**
-     * Explicit field dependencies. Required for async derivations to prevent
-     * wildcard triggering on every form change.
-     */
-    dependsOn: string[];
-    value?: never;
-    expression?: never;
-    functionName?: never;
-    http?: never;
-    responseExpression?: never;
-}
-/**
- * Base for async function derivations. `source: 'asyncFunction'` is required.
- * TypeScript enforces `dependsOn` at the type level, and `asyncFunctionName` /
- * `asyncFn` are mutually exclusive (XOR).
- *
- * @internal
- */
-type AsyncFunctionDerivationBase = (AsyncFunctionDerivationShared & {
-    /** Name of a registered async derivation function. */
-    asyncFunctionName: string;
-    /** Inline form is forbidden when `asyncFunctionName` is set */
-    asyncFn?: never;
-}) | (AsyncFunctionDerivationShared & {
-    /** Inline async derivation function. Mutually exclusive with `asyncFunctionName`. */
-    asyncFn: AsyncDerivationFunction;
-    /** Registered form is forbidden when `asyncFn` is set */
-    asyncFunctionName?: never;
-});
-/**
- * Base for expression derivations.
- *
- * @internal
- */
-interface ExpressionDerivationBase extends SharedDerivationFields {
-    source?: never;
-    /** Forbidden on expression mode */
-    fn?: never;
-    /** Forbidden on expression mode */
-    asyncFn?: never;
-    /** JavaScript expression to evaluate for the derived value. */
-    expression: string;
-    /** Explicit field dependencies for expressions. */
-    dependsOn?: string[];
-    value?: never;
-    functionName?: never;
-    http?: never;
-    asyncFunctionName?: never;
-    responseExpression?: never;
-}
-/**
- * Base for value derivations.
- *
- * @internal
- */
-interface ValueDerivationBase extends SharedDerivationFields {
-    source?: never;
-    /** Forbidden on value mode */
-    fn?: never;
-    /** Forbidden on value mode */
-    asyncFn?: never;
-    /** Static value to set on this field. */
-    value: unknown;
-    /** Explicit field dependencies for value derivations. */
-    dependsOn?: string[];
-    expression?: never;
-    functionName?: never;
-    http?: never;
-    asyncFunctionName?: never;
-    responseExpression?: never;
-}
-/**
- * Shared fields for both branches of {@link FunctionDerivationBase}.
- *
- * @internal
- */
-interface FunctionDerivationShared extends SharedDerivationFields {
-    source?: never;
-    /** Forbidden on function-derivation mode */
-    asyncFn?: never;
-    /** Explicit field dependencies for function derivations. */
-    dependsOn?: string[];
-    value?: never;
-    expression?: never;
-    http?: never;
-    asyncFunctionName?: never;
-    responseExpression?: never;
-}
-/**
- * Base for custom sync function derivations. `functionName` and `fn` are
- * mutually exclusive (XOR).
- *
- * @internal
- */
-type FunctionDerivationBase = (FunctionDerivationShared & {
-    /** Name of a registered custom derivation function. */
-    functionName: string;
-    /** Inline form is forbidden when `functionName` is set */
-    fn?: never;
-}) | (FunctionDerivationShared & {
-    /** Inline custom derivation function. Mutually exclusive with `functionName`. */
-    fn: CustomFunction;
-    /** Registered form is forbidden when `fn` is set */
-    functionName?: never;
-});
-/**
- * HTTP derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-type OnChangeHttpDerivationLogicConfig = HttpDerivationBase & ImmediateDerivationTrigger;
-/**
- * HTTP derivation that evaluates after a debounce period.
- *
- * @internal
- */
-type DebouncedHttpDerivationLogicConfig = HttpDerivationBase & DebouncedDerivationTrigger;
-/**
- * Async function derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-type OnChangeAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & ImmediateDerivationTrigger;
-/**
- * Async function derivation that evaluates after a debounce period.
- *
- * @internal
- */
-type DebouncedAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & DebouncedDerivationTrigger;
-/**
- * Expression derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-type OnChangeExpressionDerivationLogicConfig = ExpressionDerivationBase & ImmediateDerivationTrigger;
-/**
- * Expression derivation that evaluates after a debounce period.
- *
- * @internal
- */
-type DebouncedExpressionDerivationLogicConfig = ExpressionDerivationBase & DebouncedDerivationTrigger;
-/**
- * Value derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-type OnChangeValueDerivationLogicConfig = ValueDerivationBase & ImmediateDerivationTrigger;
-/**
- * Value derivation that evaluates after a debounce period.
- *
- * @internal
- */
-type DebouncedValueDerivationLogicConfig = ValueDerivationBase & DebouncedDerivationTrigger;
-/**
- * Function derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-type OnChangeFunctionDerivationLogicConfig = FunctionDerivationBase & ImmediateDerivationTrigger;
-/**
- * Function derivation that evaluates after a debounce period.
- *
- * @internal
- */
-type DebouncedFunctionDerivationLogicConfig = FunctionDerivationBase & DebouncedDerivationTrigger;
-/** Configuration for value derivation logic. */
-type DerivationLogicConfig = OnChangeHttpDerivationLogicConfig | DebouncedHttpDerivationLogicConfig | OnChangeAsyncFunctionDerivationLogicConfig | DebouncedAsyncFunctionDerivationLogicConfig | OnChangeExpressionDerivationLogicConfig | DebouncedExpressionDerivationLogicConfig | OnChangeValueDerivationLogicConfig | DebouncedValueDerivationLogicConfig | OnChangeFunctionDerivationLogicConfig | DebouncedFunctionDerivationLogicConfig;
-/** Union type for all logic configurations. */
-type LogicConfig = StateLogicConfig | DerivationLogicConfig;
-/** Log level for derivation debug output. */
-type DerivationLogLevel = 'none' | 'summary' | 'verbose';
-/**
- * Type guard to check if a condition is a FormStateCondition.
- *
- * @param condition - The condition to check
- * @returns true if the condition is a FormStateCondition
- */
-declare function isFormStateCondition(condition: StateLogicConfig['condition'] | DerivationLogicConfig['condition']): condition is FormStateCondition;
-
-/** Configuration for applying predefined schemas */
-interface SchemaApplicationConfig {
-    /** Schema application type */
-    type: 'apply' | 'applyWhen' | 'applyWhenValue' | 'applyEach';
-    /** Schema identifier or inline schema definition */
-    schema: string | SchemaDefinition;
-    /** Condition for conditional application */
-    condition?: ConditionalExpression;
-    /** Type predicate for applyWhenValue */
-    typePredicate?: string;
-}
-/** Reusable schema definition that can be referenced by name */
-interface SchemaDefinition {
-    /** Unique schema identifier */
-    name: string;
-    /** Schema description */
-    description?: string;
-    /** Field path pattern this schema applies to */
-    pathPattern?: string;
-    /** Validators to apply */
-    validators?: ValidatorConfig[];
-    /** Logic rules to apply */
-    logic?: LogicConfig[];
-    /** Nested schema applications */
-    subSchemas?: SchemaApplicationConfig[];
-}
-
-/**
- * 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.
- */
-type SubmissionActionResult = Promise<TreeValidationResult> | Observable<TreeValidationResult | unknown>;
-/**
- * Configuration for form submission handling.
- *
- * @typeParam TValue - The form value type
- */
-interface SubmissionConfig<TValue = unknown> {
-    /**
-     * Action called when the form is submitted.
-     *
-     * @param form - The form's FieldTree instance
-     * @returns Promise or Observable - for errors, return TreeValidationResult
-     */
-    action: (form: FieldTree<TValue>) => SubmissionActionResult;
-}
-
-/**
- * Configuration interface for defining dynamic form structure and behavior.
- *
- * @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)
- */
-interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, TProps extends object = Record<string, unknown>, TSchemaValue = unknown> {
-    /** Array of field definitions that define the form structure. */
-    fields: TFields;
-    /** Optional form-level validation schema using Standard Schema spec. */
-    schema?: FormSchema<TSchemaValue>;
-    /**
-     * Global form configuration options.
-     *
-     * @value {}
-     */
-    options?: FormOptions;
-    /** Global schemas available to all fields. */
-    schemas?: SchemaDefinition[];
-    /** Form-level validation messages that act as fallback for field-level messages. */
-    defaultValidationMessages?: ValidationMessages;
-    /** Signal forms adapter configuration. */
-    customFnConfig?: CustomFnConfig<TValue extends Record<string, unknown> ? TValue : Record<string, unknown>>;
-    /** Form submission configuration. */
-    submission?: SubmissionConfig<TValue>;
-    /** Default props applied to all fields in the form. */
-    defaultProps?: TProps;
-    /** External data signals available to conditional logic and derivations. */
-    externalData?: Record<string, Signal<unknown>>;
-    /** Form-wide default wrappers applied to every field that does not explicitly opt out. */
-    defaultWrappers?: readonly WrapperConfig[];
-}
-/** Signal forms adapter configuration for advanced form behavior. */
-interface CustomFnConfig<TFormValue extends Record<string, unknown> = Record<string, unknown>> {
-    /** Custom evaluation functions for conditional expressions. */
-    customFunctions?: Record<string, CustomFunction<TFormValue>>;
-    /** Custom derivation functions for value derivation logic. */
-    derivations?: Record<string, CustomFunction<TFormValue>>;
-    /** Async derivation functions for asynchronous value derivation logic. */
-    asyncDerivations?: Record<string, AsyncDerivationFunction<TFormValue>>;
-    /** Async condition functions for asynchronous field state logic. */
-    asyncConditions?: Record<string, AsyncConditionFunction<TFormValue>>;
-    /** Custom validators using Angular's public FieldContext API */
-    validators?: Record<string, CustomValidator>;
-    /** Async custom validators using Angular's resource-based validateAsync() API */
-    asyncValidators?: Record<string, AsyncCustomValidator>;
-    /** HTTP validators using Angular's validateHttp() API. */
-    httpValidators?: Record<string, HttpCustomValidator>;
-}
-/** Global form configuration options. */
-interface FormOptions {
-    /**
-     * Disable the entire form.
-     *
-     * @value false
-     */
-    disabled?: boolean;
-    /**
-     * Prefix scoping every field's DOM `id` (and matching `for` / `data-testid` /
-     * `aria-describedby`) to this form instance, as the outermost id segment:
-     * `{idPrefix}_{group}_{key}_{index}`. Use it when rendering multiple forms
-     * from the same config on one page so their ids don't collide.
-     *
-     * When omitted, a lone form stays unprefixed and a generated prefix (`df-1`,
-     * `df-2`, …) is applied automatically once a second form is mounted. Characters
-     * invalid in an id token (whitespace, punctuation) are replaced with `_`.
-     *
-     * @example
-     * ```typescript
-     * options: { idPrefix: 'billing' } // → id="billing_email-input"
-     * ```
-     *
-     * @default undefined (auto-prefix only when multiple forms are mounted)
-     */
-    idPrefix?: string;
-    /**
-     * Maximum number of iterations for derivation chain processing.
-     *
-     * @default 10
-     */
-    maxDerivationIterations?: number;
-    /** Default disabled behavior for submit buttons. */
-    submitButton?: SubmitButtonOptions;
-    /** Default disabled behavior for next page buttons. */
-    nextButton?: NextButtonOptions;
-    /**
-     * Whether to exclude values of hidden fields from submission output.
-     *
-     * @default undefined (uses global setting)
-     */
-    excludeValueIfHidden?: boolean;
-    /**
-     * Whether to exclude values of disabled fields from submission output.
-     *
-     * @default undefined (uses global setting)
-     */
-    excludeValueIfDisabled?: boolean;
-    /**
-     * Whether to exclude values of readonly fields from submission output.
-     *
-     * @default undefined (uses global setting)
-     */
-    excludeValueIfReadonly?: boolean;
-    /**
-     * Whether to run validation when a field is hidden.
-     *
-     * @default undefined (uses global setting, which defaults to `false`)
-     */
-    validateWhenHidden?: boolean;
-    /**
-     * Whether to attach the current form value to all events dispatched through the EventBus.
-     *
-     * @default undefined (uses global setting)
-     */
-    emitFormValueOnEvents?: boolean;
-}
-/** Options for controlling submit button disabled behavior. */
-interface SubmitButtonOptions {
-    /**
-     * Disable submit button when the form is invalid.
-     *
-     * @default true
-     */
-    disableWhenInvalid?: boolean;
-    /**
-     * Disable submit button while the form is submitting.
-     *
-     * @default true
-     */
-    disableWhileSubmitting?: boolean;
-}
-/** Options for controlling next page button disabled behavior. */
-interface NextButtonOptions {
-    /**
-     * Disable next button when the current page has invalid fields.
-     *
-     * @default true
-     */
-    disableWhenPageInvalid?: boolean;
-    /**
-     * Disable next button while the form is submitting.
-     *
-     * @default true
-     */
-    disableWhileSubmitting?: boolean;
-}
-
-/** Context for resolving button disabled state. */
-interface ButtonLogicContext {
-    /** 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) */
-    fieldLogic?: LogicConfig[];
-    /** Explicit disabled state from field definition */
-    explicitlyDisabled?: boolean;
-    /** Current page validity signal (for paged forms) */
-    currentPageValid?: Signal<boolean>;
-    /** Current form value for evaluating conditional expressions */
-    formValue?: unknown;
-    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
-    logger?: Logger;
-}
-/**
- * Allowed logic types for non-form-bound elements (buttons, text fields, etc.).
- * These elements only support hidden and disabled states - not readonly or required
- * since they don't participate in form validation.
- */
-type NonFieldLogicType = 'hidden' | 'disabled';
-/**
- * Logic config restricted to types valid for non-form-bound elements.
- * This is a subset of LogicConfig that only includes hidden and disabled types.
- */
-type NonFieldLogicConfig = LogicConfig & {
-    type: NonFieldLogicType;
-};
-/** Context for resolving state (hidden/disabled) for non-form-bound elements. */
-interface NonFieldLogicContext {
-    /** The form's FieldTree instance (supports both string and number keys for array indices) */
-    form: FieldTree<unknown, string | number>;
-    /**
-     * Field-level logic array containing conditions.
-     * Accepts full LogicConfig[] for compatibility, but only hidden and disabled types are processed.
-     */
-    fieldLogic?: LogicConfig[];
-    /** Explicit state from field definition (e.g., `hidden: true` or `disabled: true`) */
-    explicitValue?: 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.
- *
- * @param ctx - The button logic context
- * @returns A computed signal that returns true when the button should be disabled
- */
-declare function resolveSubmitButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
-/**
- * Resolves the disabled state for a next page button.
- *
- * @param ctx - The button logic context
- * @returns A computed signal that returns true when the button should be disabled
- */
-declare function resolveNextButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
-/**
- * Evaluates the hidden state for non-form-bound elements synchronously.
- *
- * @param ctx - The context containing form, logic array, and explicit hidden state
- * @returns true when the element should be hidden
- */
-declare function evaluateNonFieldHidden(ctx: NonFieldLogicContext): boolean;
-/**
- * Resolves the hidden state for non-form-bound elements as a reactive signal.
- *
- * @param ctx - The context containing form, logic array, and explicit hidden state
- * @returns A computed signal that returns true when the element should be hidden
- */
-declare function resolveNonFieldHidden(ctx: NonFieldLogicContext): Signal<boolean>;
-/**
- * Evaluates the disabled state for non-form-bound elements synchronously.
- *
- * @param ctx - The context containing form, logic array, and explicit disabled state
- * @returns true when the element should be disabled
- */
-declare function evaluateNonFieldDisabled(ctx: NonFieldLogicContext): boolean;
-/**
- * Resolves the disabled state for non-form-bound elements as a reactive signal.
- *
- * @param ctx - The context containing form, logic array, and explicit disabled state
- * @returns A computed signal that returns true when the element should be disabled
- */
-declare function resolveNonFieldDisabled(ctx: NonFieldLogicContext): Signal<boolean>;
-
-/** Text element type for rendering different HTML text elements */
-type TextElementType = 'p' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span';
-/** Properties for text field configuration */
-type TextProps = {
-    /** The HTML element type to render */
-    elementType: TextElementType;
-};
-/** Text field definition for displaying translatable text content */
-interface TextField extends FieldDef<TextProps> {
-    type: 'text';
-    /**
-     * Logic rules for conditional visibility.
-     * Text fields only support 'hidden' logic type since they are display-only
-     * and don't participate in form validation (no disabled/readonly/required).
-     */
-    readonly logic?: NonFieldLogicConfig[];
-}
-
-/**
- * Scalar types supported by hidden fields.
- * These are the primitive value types that can be stored.
- */
-type HiddenScalar = string | number | boolean;
-/**
- * All value types supported by hidden fields.
- * Supports both scalar values and arrays of scalars for storing
- * multiple IDs or similar data.
- */
-type HiddenValue = HiddenScalar | HiddenScalar[];
-/**
- * Hidden field definition for storing values without rendering UI.
- *
- * @typeParam TValue - The type of value stored (must be HiddenValue compatible)
- */
-interface HiddenField<TValue extends HiddenValue = HiddenValue> extends FieldDef<never> {
-    /** Discriminant for hidden field type */
-    type: 'hidden';
-    /**
-     * The value to store in the form.
-     * This is required - a hidden field without a value serves no purpose.
-     */
-    value: TValue;
-}
-
-/** Configuration for the built-in 'css' wrapper type. */
-interface CssWrapper {
-    readonly type: 'css';
-    /** CSS classes to apply to the wrapper */
-    readonly cssClasses?: DynamicText;
-}
-
-/** Configuration for the built-in 'row' wrapper type. */
-interface RowWrapper {
-    readonly type: 'row';
-}
-
-/** Resolves a wrapper type name to its registered config interface. */
-type WrapperConfig<TWrappers extends RegisteredWrapperTypes = RegisteredWrapperTypes> = TWrappers extends keyof FieldRegistryWrappers ? FieldRegistryWrappers[TWrappers] : {
-    readonly type: TWrappers;
-};
-/**
- * Signature of a lazy component loader — either a direct component class or
- * an ES module whose `default` export is the component. Shared by field and
- * wrapper registrations so the `loadComponent: () => import('./x.component')`
- * idiom types cleanly in both places.
- */
-type LazyComponentLoader<T = unknown> = () => Promise<Type<T> | {
-    default: Type<T>;
-}>;
-/** Configuration interface for registering wrapper types. */
-interface WrapperTypeDefinition<T extends WrapperConfig = WrapperConfig> {
-    /** Unique identifier for the wrapper type (also serves as discriminant from FieldTypeDefinition) */
-    wrapperName: string;
-    /** Wrapper definition type marker (internal use) */
-    _wrapper?: T;
-    /**
-     * Function to load the wrapper component (supports lazy loading).
-     * Returns a Promise that resolves to the component class or module with default export.
-     */
-    loadComponent: LazyComponentLoader;
-    /** Field types this wrapper should auto-apply to. */
-    types?: readonly string[];
-}
-/** Type guard for WrapperTypeDefinition. */
-declare function isWrapperTypeDefinition(value: unknown): value is WrapperTypeDefinition;
-/**
- * Contract that wrapper components must satisfy.
- *
- * @Component({
- *   template: `
- *     <dbx-section [header]="header() ?? ''">
- *       <ng-container #fieldComponent></ng-container>
- *     </dbx-section>
- *   `,
- * })
- * export class SectionWrapperComponent implements FieldWrapper {
- *   readonly fieldComponent = viewChild.required('fieldComponent', { read: ViewContainerRef });
- *   readonly header = input<string>();
- *   readonly fieldInputs = input<WrapperFieldInputs>();
- * }
- * ```
- */
-interface FieldWrapper {
-    /** ViewContainerRef slot where inner content is rendered */
-    readonly fieldComponent: Signal<ViewContainerRef>;
-}
-/** Injection token for the wrapper type registry. */
-declare const WRAPPER_REGISTRY: InjectionToken<Map<string, WrapperTypeDefinition<RowWrapper | _ng_forge_dynamic_forms.CssWrapper>>>;
-
-/** Container field interface for wrapping child fields with UI chrome. */
-interface ContainerField<TFields extends readonly ContainerAllowedChildren[] = readonly ContainerAllowedChildren[], TWrapperConfigs extends readonly WrapperConfig[] = readonly WrapperConfig[]> extends FieldDef<never> {
-    type: 'container';
-    /** Child definitions to render within this container */
-    readonly fields: TFields;
-    /**
-     * Wrapper components to chain around the children.
-     * Applied outermost-first: the first wrapper in the array is the outermost.
-     * Each wrapper component receives the subsequent wrapper (or children) inside
-     * its `#fieldComponent` ViewContainerRef slot.
-     */
-    readonly wrappers: TWrapperConfigs;
-    /** Container fields do not have a label property */
-    readonly label?: never;
-    /** Containers do not support meta — they have no native form element */
-    readonly meta?: never;
-    /**
-     * Logic configurations for conditional container visibility.
-     * Only 'hidden' type logic is supported for containers.
-     */
-    readonly logic?: ContainerLogicConfig[];
-}
-/** Type guard for ContainerField with proper type narrowing. */
-declare function isContainerTypedField(field: FieldDef<any>): field is ContainerField;
-
-/**
- * Type constraints for field nesting rules
- * These ensure that container fields can only contain valid child field types
- */
-/**
- * Fields that are allowed as children of Page fields
- * Pages can contain: rows, groups, arrays, and leaf fields (but NOT other pages)
- */
-type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
-/**
- * Fields that are allowed as children of Group fields
- * Groups can contain: rows, arrays, and leaf fields (but NOT pages or other groups)
- */
-type GroupAllowedChildren = LeafFieldTypes | RowField | ArrayField | SimplifiedArrayField | ContainerField;
-/**
- * Fields that are allowed as children of Array fields
- * Arrays can contain: rows, groups, and leaf fields (but NOT pages or other arrays)
- * Groups are used for creating object arrays where each array item is an object
- */
-type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField | ContainerField;
-/**
- * Fields that are allowed as children of Container fields.
- * Containers are pure layout primitives that flatten their children into the
- * parent form, so most registered field types may appear inside — including
- * hidden fields and other containers — but NOT pages.
- */
-type ContainerAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
-/**
- * Row is a synthetic field type that resolves to a Container at runtime, so
- * it accepts the same children as a Container.
- */
-type RowAllowedChildren = ContainerAllowedChildren;
-
-/**
- * An array item template is an array of allowed children that defines one OBJECT array item's fields.
- * Used for object arrays where each item is `{ key1: value1, key2: value2, ... }`.
- */
-type ArrayItemTemplate = readonly ArrayAllowedChildren[];
-/**
- * An array item definition can be either:
- * - A single field (ArrayAllowedChildren) for PRIMITIVE array items - extracts field value directly
- * - An array of fields (ArrayItemTemplate) for OBJECT array items - merges fields into object
- */
-type ArrayItemDefinition = ArrayAllowedChildren | ArrayItemTemplate;
-/** Array field interface for creating dynamic field collections that map to array values. */
-interface ArrayField<TFields extends readonly ArrayItemDefinition[] = readonly ArrayItemDefinition[]> extends FieldDef<never> {
-    type: 'array';
-    /**
-     * Array of item definitions. Each element defines one array item:
-     * - Single FieldDef = primitive item (field's value is extracted directly)
-     * - Array of FieldDefs = object item (fields are merged into an object)
-     * - Empty array `[]` = no initial items (add via buttons with explicit templates)
-     * - Items can have different configurations (heterogeneous arrays supported)
-     * - Initial values are set via `value` property on each field definition
-     */
-    readonly fields: TFields;
-    /** Array fields do not have a label property * */
-    readonly label?: never;
-    /** Arrays do not support meta - they have no native form element * */
-    readonly meta?: never;
-    /**
-     * Logic configurations for conditional array visibility.
-     * Only 'hidden' type logic is supported for arrays.
-     */
-    readonly logic?: ContainerLogicConfig[];
-    /**
-     * Minimum number of items required in the array.
-     * Validation fails if the array has fewer items than this value.
-     */
-    readonly minLength?: number;
-    /**
-     * Maximum number of items allowed in the array.
-     * Validation fails if the array has more items than this value.
-     */
-    readonly maxLength?: number;
-}
-/**
- * Type guard for ArrayField with proper type narrowing.
- * Validates that the field is an array type with a fields property that is an array.
- * Fields can contain either single FieldDefs (primitive items) or arrays of FieldDefs (object items).
- */
-declare function isArrayField(field: FieldDef<any>): field is ArrayField;
-/** Configuration for auto-generated add/remove buttons in simplified array fields. */
-interface ArrayButtonConfig {
-    /** Custom label for the button */
-    readonly label?: string;
-    /** Additional properties passed to the button component */
-    readonly props?: Record<string, unknown>;
-}
-/** Simplified array field interface for common use cases. */
-interface SimplifiedArrayField extends FieldDef<never> {
-    type: 'array';
-    /**
-     * Template defining the structure of a single array item.
-     * - Single field (ArrayAllowedChildren) → primitive array (each item is a single value)
-     * - Array of fields (readonly ArrayAllowedChildren[]) → object array (each item is an object)
-     */
-    readonly template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
-    /** Initial values for the array. Each element creates one array item. */
-    readonly value?: readonly unknown[];
-    /**
-     * Configuration for the auto-generated "Add" button, or `false` to disable it.
-     * Defaults to a button with label "Add".
-     */
-    readonly addButton?: ArrayButtonConfig | false;
-    /**
-     * Configuration for the auto-generated "Remove" button on each item, or `false` to disable it.
-     * Defaults to a button with label "Remove".
-     */
-    readonly removeButton?: ArrayButtonConfig | false;
-    /** Simplified arrays do not support the label property */
-    readonly label?: never;
-    /** Simplified arrays do not support meta */
-    readonly meta?: never;
-    /**
-     * Logic configurations for conditional array visibility.
-     * Only 'hidden' type logic is supported for arrays.
-     */
-    readonly logic?: ContainerLogicConfig[];
-    /**
-     * Minimum number of items required in the array.
-     * Validation fails if the array has fewer items than this value.
-     */
-    readonly minLength?: number;
-    /**
-     * Maximum number of items allowed in the array.
-     * Validation fails if the array has more items than this value.
-     */
-    readonly maxLength?: number;
-    /** Mutually exclusive with `template` — use `fields` for the full API instead */
-    readonly fields?: never;
-}
-/**
- * Type guard for SimplifiedArrayField.
- * Checks for `type: 'array'` with a `template` property (discriminant from full ArrayField).
- */
-declare function isSimplifiedArrayField(field: FieldDef<any>): field is SimplifiedArrayField;
-
-/** Container fields registry - augment this interface to add custom container fields */
-interface FieldRegistryContainers {
-    page: PageField;
-    row: RowField;
-    group: GroupField;
-    array: ArrayField | SimplifiedArrayField;
-    container: ContainerField;
-}
-/** Leaf fields registry - augment this interface to add custom leaf fields */
-interface FieldRegistryLeaves {
-    text: TextField;
-    hidden: HiddenField;
-}
-/** Wrapper type registry for module augmentation. */
-interface FieldRegistryWrappers {
-    css: CssWrapper;
-    row: RowWrapper;
-}
-/**
- * Global interface for dynamic form field definitions with categorization
- * This interface combines containers and leaves from their respective registries
- */
-interface DynamicFormFieldRegistry {
-    /** Container fields that hold other fields (no value, have children) */
-    containers: FieldRegistryContainers;
-    /** Leaf fields that have values or display content */
-    leaves: FieldRegistryLeaves;
-    /** Field wrappers types */
-    wrappers: FieldRegistryWrappers;
-}
-/** Union type of all registered container field definitions */
-type ContainerFieldTypes = DynamicFormFieldRegistry['containers'][keyof DynamicFormFieldRegistry['containers']];
-/** Union type of all registered leaf field definitions */
-type LeafFieldTypes = DynamicFormFieldRegistry['leaves'][keyof DynamicFormFieldRegistry['leaves']];
-/** Union type of all registered field definitions */
-type RegisteredFieldTypes = ContainerFieldTypes | LeafFieldTypes;
-/** Extract field types that are available in the registry */
-type AvailableFieldTypes = keyof DynamicFormFieldRegistry['containers'] | keyof DynamicFormFieldRegistry['leaves'];
-/** Extract wrapper types that are available in the registry */
-type RegisteredWrapperTypes = keyof DynamicFormFieldRegistry['wrappers'];
-/**
- * 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.
- */
-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.
- */
-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.
- */
-type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
-
-/** Base interface for native HTML attributes that can be passed to form field elements. */
-interface FieldMeta {
-    /** Allows any data-* attribute */
-    [key: `data-${string}`]: string | undefined;
-    /** Allows any aria-* attribute */
-    [key: `aria-${string}`]: string | boolean | undefined;
-    /** Allows additional custom attributes as escape hatch */
-    [key: string]: string | number | boolean | undefined;
-}
-
-/**
- * Base interface for all dynamic form field definitions.
- *
- * @typeParam TProps - Field-specific properties interface
- * @typeParam TMeta - Native HTML attributes interface (extends FieldMeta)
- */
-interface FieldDef<TProps, TMeta extends FieldMeta = FieldMeta> {
-    /** Unique field identifier used for form binding and value tracking. */
-    key: string;
-    /** Field type identifier for component selection. */
-    type: RegisteredFieldTypes['type'] | (string & {});
-    /** Human-readable field label displayed to users. */
-    label?: DynamicText;
-    /** Field-specific properties and configuration options. */
-    props?: TProps;
-    /** Native HTML attributes to pass through to the underlying element. */
-    meta?: TMeta;
-    /** Additional CSS classes for custom styling. */
-    className?: string;
-    /**
-     * Whether the field is disabled and cannot be interacted with.
-     *
-     * @value false
-     */
-    disabled?: boolean;
-    /**
-     * Whether the field is read-only.
-     *
-     * @value false
-     */
-    readonly?: boolean;
-    /**
-     * Whether the field is hidden from view.
-     *
-     * @value false
-     */
-    hidden?: boolean;
-    /** Tab index for keyboard navigation. */
-    tabIndex?: number | undefined;
-    /**
-     * Whether to exclude this field's value from submission output when hidden.
-     *
-     * @default undefined (uses form-level or global setting)
-     */
-    excludeValueIfHidden?: boolean;
-    /**
-     * Whether to exclude this field's value from submission output when disabled.
-     *
-     * @default undefined (uses form-level or global setting)
-     */
-    excludeValueIfDisabled?: boolean;
-    /**
-     * Whether to exclude this field's value from submission output when readonly.
-     *
-     * @default undefined (uses form-level or global setting)
-     */
-    excludeValueIfReadonly?: boolean;
-    /**
-     * Whether to run validation when this field is hidden — statically (`hidden: true`),
-     * via a `hidden` logic rule, or via any hidden ancestor.
-     *
-     * @default undefined — inherits from parent / form / global default (which is `false`)
-     */
-    validateWhenHidden?: boolean;
-    /**
-     * Column sizing configuration for responsive grid layout.
-     *
-     * @value 12
-     */
-    col?: number;
-    /** Wrapper components to chain around this field. */
-    wrappers?: readonly WrapperConfig[] | null;
-    /**
-     * Skip the auto-association layer (`WrapperTypeDefinition.types`) while
-     * keeping form-level defaults and any field-level `wrappers`. Use when a
-     * global wrapper auto-applies to this field type but isn't wanted here.
-     */
-    skipAutoWrappers?: boolean;
-    /**
-     * Skip the form-level `defaultWrappers` layer while keeping auto-associations
-     * and any field-level `wrappers`.
-     */
-    skipDefaultWrappers?: boolean;
-    /** Addons rendered inside this field's slots (typically `prefix` / `suffix`). */
-    addons?: ReadonlyArray<AnyAddon>;
-}
-type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
-/**
- * Type utility for extracting component input properties from field definitions.
- *
- * @Component({...})
- * export class MyFieldComponent implements FieldComponent<MyFieldDef> {
- *   label = input<string>();
- *   className = input<string>();
- *   hidden = input<boolean>();
- *   tabIndex = input<number>();
- * }
- * ```
- * @typeParam T - Field definition type to extract properties from
- */
-type FieldComponent<T extends FieldDef<unknown, FieldMeta>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
-
-/**
- * Field signal context - the "nervous system" of the dynamic form.
- * Provided via FIELD_SIGNAL_CONTEXT injection token.
- */
-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>;
-}
-/** Group context for fields rendered inside `group` containers. */
-interface GroupContext {
-    /** Dot-separated path of group ancestors, including the current group's key (e.g. `'address'` or `'user.address'`). */
-    groupPath: Signal<string>;
-}
-/** Mapper function that converts a field definition to component inputs. */
-type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string, unknown>>;
-
-/**
- * Minimal JSON Schema fragment used by the MCP server to surface an addon
- * kind's shape to AI form generators. Covers the common subset
- * (`type`/`properties`/`required`/`enum`/etc.) without pulling in a full JSON
- * Schema dependency. Extra keys are allowed via the `[key: string]` index so
- * vendor-specific annotations (`x-foo`, `markdownDescription`) still typecheck.
- */
-interface AddonKindSchema {
-    readonly $ref?: string;
-    readonly $schema?: string;
-    readonly title?: string;
-    readonly description?: string;
-    readonly type?: 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null' | ReadonlyArray<'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null'>;
-    readonly enum?: ReadonlyArray<unknown>;
-    readonly const?: unknown;
-    readonly properties?: Readonly<Record<string, AddonKindSchema>>;
-    readonly required?: ReadonlyArray<string>;
-    readonly additionalProperties?: boolean | AddonKindSchema;
-    readonly items?: AddonKindSchema | ReadonlyArray<AddonKindSchema>;
-    readonly oneOf?: ReadonlyArray<AddonKindSchema>;
-    readonly anyOf?: ReadonlyArray<AddonKindSchema>;
-    readonly allOf?: ReadonlyArray<AddonKindSchema>;
-    readonly not?: AddonKindSchema;
-    readonly default?: unknown;
-    readonly examples?: ReadonlyArray<unknown>;
-    readonly minimum?: number;
-    readonly maximum?: number;
-    readonly minLength?: number;
-    readonly maxLength?: number;
-    readonly pattern?: string;
-    readonly format?: string;
-    /** Vendor extensions and unrecognised keywords pass through untyped. */
-    readonly [key: string]: unknown;
-}
-/**
- * Optional shape validator a kind ships to enforce its required fields at
- * runtime. Throws are caught by the validator and converted into lenient
- * warnings; the offending addon is dropped and the form keeps rendering.
- */
-type AddonShapeValidator<T extends BaseAddon = BaseAddon> = (addon: T, fieldKey: string) => void;
-/** Per-kind registration metadata. */
-interface AddonKindDefinition<T extends BaseAddon = BaseAddon> {
-    /** Discriminant matching `addon.kind`. */
-    readonly kind: string;
-    /** Lazy loader for the kind's renderer component. */
-    readonly loadComponent: LazyComponentLoader;
-    /** Optional shape validator — throw `DynamicFormError` to drop the addon with a warning. */
-    readonly validate?: AddonShapeValidator<T>;
-    /** Optional JSON Schema fragment for MCP / pre-flight tooling. */
-    readonly schema?: AddonKindSchema;
-    /**
-     * Whether the kind survives `JSON.stringify` / `JSON.parse`. Kinds whose
-     * shape includes a function payload (e.g., the built-in `'component'`
-     * loader, inline `prime-button` `action` handlers) declare `jsonSafe: false`
-     * so the validator drops them when the config was loaded from a JSON
-     * source (`sanitizeFormConfig(config, { source: 'json' })`). Defaults to
-     * `true` — kinds are JSON-safe unless explicitly opted out.
-     */
-    readonly jsonSafe?: boolean;
-}
-/** Per-field-type addon-support metadata declared at field registration. */
-interface FieldAddonSupport {
-    /** Slots a field of this type accepts. */
-    readonly slots: readonly AddonSlot[];
-    /** Optional whitelist of allowed addon kinds. Omitted = any registered kind. */
-    readonly allowedKinds?: readonly string[];
-}
-/** Global registry of addon kinds. */
-declare const ADDON_KIND_REGISTRY: InjectionToken<Map<string, AddonKindDefinition<BaseAddon<AddonSlot>>>>;
-
-/** Defines how a field type handles form values and data collection. */
-type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
-/** Semantic grouping of interchangeable field UI alternatives. */
-type FieldScope = 'boolean' | 'single-select' | 'multi-select' | 'text-input' | 'numeric' | 'date';
-/** Mapped component inputs that must be available before a field component is instantiated. */
-type RenderReadyInput = 'field' | (string & {});
-/**
- * Configuration interface for registering custom field types.
- *
- * @typeParam T - The field definition type this field type handles
- */
-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.
-     */
-    loadComponent?: LazyComponentLoader;
-    /** Mapper function that converts field definition to component bindings. */
-    mapper?: MapperFn<T>;
-    /** How this field type handles form values and data collection (defaults to 'include') */
-    valueHandling?: ValueHandlingMode;
-    /** List of prop keys to forward to the meta object. */
-    propsToMeta?: string[];
-    /** Semantic scope for tooling to discover interchangeable field alternatives */
-    scope?: FieldScope | FieldScope[];
-    /** Mapped component inputs that must exist before the renderer instantiates the component */
-    renderReadyWhen?: readonly RenderReadyInput[];
-    /**
-     * Declares which addon slots this field accepts and (optionally) the
-     * subset of kinds allowed.
-     */
-    addons?: FieldAddonSupport;
-}
-/** Injection token for the global field type registry. */
-declare const FIELD_REGISTRY: InjectionToken<Map<string, FieldTypeDefinition<any>>>;
+import { Type, Injector, Signal, EnvironmentInjector, WritableSignal, Provider, EnvironmentProviders, TemplateRef, InjectionToken } from '@angular/core';
+import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
+import { FieldDef, FormEvent, RegisteredFieldTypes, InferFormValue as InferFormValue$1, FormConfig, FormOptions, EventBus, LazyComponentLoader, WrapperTypeDefinition, FieldTypeDefinition, DerivationLogLevel, Logger, ValueExclusionConfig, ValidationExecutionConfig, AnyAddon, WrapperFieldInputs, TextAddon, TemplateAddon, ComponentAddon, AddonActionPreset, AddonActionContext, AddonKindDefinition, FieldAddonSupport, BaseAddon, ArrayItemDefinition, NarrowFields, AvailableFieldTypes, ExtractField } from '@ng-forge/dynamic-forms/internal';
+export { ADDON_KIND_REGISTRY, AddonActionContext, AddonActionPreset, AddonKindDefinition, AddonKindSchema, AddonShapeValidator, AddonSlot, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldAddonSupport, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormValue, LeafFieldTypes, Logger, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, Prettify, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueType, WRAPPER_REGISTRY, WithInputSignals, WrapperConfig, WrapperTypeDefinition, evaluateNonFieldDisabled, evaluateNonFieldHidden, hasFormValue, isArrayField, isCheckedField, isContainerField, isContainerTypedField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, isWrapperTypeDefinition, resolveDynamicValue, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled } from '@ng-forge/dynamic-forms/internal';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { FieldTree } from '@angular/forms/signals';
+import * as _angular_forms from '@angular/forms';
+import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
+import { FormSchema } from '@ng-forge/dynamic-forms/schema';
 
 /** Resolved field ready for rendering with ngComponentOutlet / DfFieldOutlet. */
 interface ResolvedField {
@@ -1935,50 +30,12 @@ interface ResolvedField {
     hidden: Signal<boolean>;
 }
 
-/** Form mode enumeration distinguishing between paged and non-paged forms */
-type FormMode = 'paged' | 'non-paged';
-/** Result of form mode detection with validation details */
-interface FormModeDetectionResult {
-    /** The detected form mode */
-    mode: FormMode;
-    /** Whether the form configuration is valid for the detected mode */
-    isValid: boolean;
-    /** Array of validation errors if form is invalid */
-    errors: string[];
-}
-
 /** Error from async field component loading. */
 interface FieldLoadingError {
     readonly fieldType: string;
     readonly fieldKey: string;
-    readonly error: Error;
-}
-
-/** Base interface for all form events in the dynamic form system. */
-interface FormEvent {
-    /** Unique identifier for the event type used for filtering and subscriptions */
-    readonly type: string;
-    /**
-     * Optional form value attached to the event when `withEventFormValue()` is enabled
-     * or `options.emitFormValueOnEvents` is set to `true` in the form config.
-     */
-    readonly formValue?: unknown;
+    readonly error: Error;
 }
-/**
- * Type guard to check if a form event has a form value attached.
- *
- * @param event - The form event to check
- * @returns `true` if the event has a form value attached, narrowing the type
- */
-declare function hasFormValue<T extends FormEvent>(event: T): event is T & {
-    formValue: unknown;
-};
-/**
- * Constructor type for form event classes.
- *
- * @typeParam T - The form event type being constructed
- */
-type FormEventConstructor<T extends FormEvent = FormEvent> = new (...args: any[]) => T;
 
 /** Event dispatched when the form should be cleared. */
 declare class FormClearEvent implements FormEvent {
@@ -2086,11 +143,11 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
         emitFormValueOnEvents?: boolean;
     }>;
     /** Field signal context for injection into child components */
-    fieldSignalContext: Signal<_ng_forge_dynamic_forms.FieldSignalContext<TModel>>;
+    fieldSignalContext: Signal<_ng_forge_dynamic_forms_internal.FieldSignalContext<TModel>>;
     /** Default values computed from field definitions */
     defaultValues: WritableSignal<TModel>;
     /** The Angular Signal Form instance */
-    form: Signal<FieldTree<TModel, string | number>>;
+    form: Signal<FieldTree<TModel, string | number, "writable">>;
     /** Current form values (reactive) */
     formValue: Signal<TModel | (TModel extends infer T ? T extends TModel ? T extends _angular_forms.AbstractControl<unknown, infer TValue extends unknown, any> ? TValue : never : never : never)>;
     /** Whether the form is currently valid */
@@ -2110,6 +167,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Collects errors from async field component loading for error boundary patterns */
     fieldLoadingErrors: WritableSignal<FieldLoadingError[]>;
     /** Whether to render the form template */
+    private derivationReady;
     shouldRender: Signal<boolean>;
     /** Resolved fields ready for rendering */
     protected resolvedFields: Signal<ResolvedField[]>;
@@ -2163,63 +221,6 @@ 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; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; "reset": "reset"; "cleared": "cleared"; "events": "events"; "initialized": "initialized"; "onPageChange": "onPageChange"; "onPageNavigationStateChange": "onPageNavigationStateChange"; }, ["_projectedTemplates"], never, true, never>;
 }
 
-declare class EventBus {
-    private readonly pipeline$;
-    private readonly globalEmitFormValue;
-    private readonly rootFormRegistry;
-    private readonly formOptions;
-    private readonly logger;
-    events$: Observable<FormEvent>;
-    /**
-     * Dispatches a pre-created event instance directly.
-     *
-     * @param event - A FormEvent instance to dispatch
-     */
-    dispatch(event: FormEvent): void;
-    /**
-     * Dispatches an event to all subscribers by instantiating the provided constructor.
-     *
-     * @param eventConstructor - Constructor function for the event to dispatch
-     * @param args - Arguments to pass to the event constructor
-     */
-    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
-    /**
-     * Dispatches a pre-created event instance directly.
-     * Used internally by EventDispatcher to forward events into the bus.
-     *
-     * @internal
-     */
-    emitInstance(event: FormEvent): void;
-    /**
-     * Shared emit path for both dispatch() and emitInstance().
-     * Attaches form value if configured, then pushes to the pipeline.
-     */
-    private emit;
-    /**
-     * Emits an event through the pipeline. Catches any synchronous exception that escapes
-     * RxJS's own error handling so dispatch() callers are never disrupted by a failing subscriber.
-     */
-    private safeEmit;
-    /** Determines whether form value should be attached to events. */
-    private shouldEmitFormValue;
-    /**
-     * Subscribes to events of a specific type.
-     *
-     * @param eventType - The type of event to subscribe to
-     * @returns Observable that emits events of the specified type
-     */
-    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
-    /**
-     * Subscribes to events of multiple types.
-     *
-     * @param eventType - Array of event types to subscribe to
-     * @returns Observable that emits events matching any of the specified types
-     */
-    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventBus, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventBus>;
-}
-
 /**
  * Injectable service for dispatching events into a DynamicForm from outside the form.
  *
@@ -2326,46 +327,6 @@ type InferWrapperRegistry<T> = T extends WrappersBundle<infer R> ? {
     };
 } : never;
 
-/**
- * Type guard to check if a field is a container field (page, row, group, or array)
- * Container fields have a 'fields' property and don't contribute values directly.
- * This overload works with RegisteredFieldTypes for full type narrowing.
- */
-declare function isContainerField(field: RegisteredFieldTypes): field is ContainerFieldTypes;
-/**
- * Type guard to check if a field is a container field (page, row, group, or array).
- * This overload works with any FieldDef for looser type checking.
- */
-declare function isContainerField(field: FieldDef<unknown>): boolean;
-/**
- * Type guard to check if a field is a leaf field (value or display field)
- * Leaf fields don't have children and either contribute values or display content
- */
-declare function isLeafField(field: RegisteredFieldTypes): field is LeafFieldTypes;
-/**
- * Type guard to check if a field has a value property (value-bearing field)
- * These fields contribute to the form value output
- * Note: Using `unknown` in the Extract condition to match any value type
- */
-declare function isValueBearingField(field: RegisteredFieldTypes): field is Extract<RegisteredFieldTypes, {
-    value: unknown;
-}>;
-/**
- * Type guard to check if a field is excluded from form values (display-only field)
- * Currently this includes text fields and any other fields without a value property
- */
-declare function isDisplayOnlyField(field: RegisteredFieldTypes): boolean;
-
-/** Helper types for creating type-safe field configurations with proper nesting constraints */
-
-/**
- * Type helper for accessing nested field paths safely
- * This allows accessing child paths while maintaining some type safety
- */
-type FieldPathAccess<TValue> = {
-    [K in keyof TValue]: SchemaPath<TValue[K]> | SchemaPathTree<TValue[K]>;
-};
-
 /** Extract FieldDef type from FieldTypeDefinition */
 type ExtractFieldDef<T> = T extends FieldTypeDefinition<infer F> ? F : never;
 /** Union of all FieldDef types from provided field types */
@@ -2400,142 +361,6 @@ type ExtractFormValue<T> = T extends {
     __formValue?: infer V;
 } ? V : never;
 
-/**
- * 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;
-/** Read-only view of a single field's observable state. */
-interface ReadonlyFieldTree<TValue = unknown> {
-    readonly value: Signal<TValue>;
-    readonly valid: Signal<boolean>;
-    readonly invalid: Signal<boolean>;
-    readonly touched: Signal<boolean>;
-    readonly dirty: Signal<boolean>;
-    readonly required: Signal<boolean>;
-    readonly disabled: Signal<boolean>;
-    readonly hidden: Signal<boolean>;
-    readonly errors: Signal<readonly unknown[]>;
-}
-/**
- * Build a `ReadonlyFieldTree` by extracting the whitelisted read signals from a
- * Signal Forms `FieldTree`. Returns a fresh plain object — no casting, no proxying,
- * so consumers only see the narrow surface and Angular's `WritableSignal` capability
- * on `value` is hidden.
- */
-declare function toReadonlyFieldTree<TValue>(field: FieldTree<TValue>): ReadonlyFieldTree<TValue>;
-/**
- * Write a value into a FieldTree's underlying signal. Signal Forms stores
- * `FieldState.value` as a `WritableSignal`; this helper centralises the cast
- * and warns if that contract ever changes (vs a silent no-op).
- */
-declare function writeToFieldValue<T>(value: Signal<T>, next: T, logger?: {
-    warn: (msg: string) => void;
-}): boolean;
-
-/**
- * Fields every addon-action context carries, regardless of whether the
- * addon is bound to a host field or rendered orphaned.
- */
-interface AddonActionContextBase<TValue> {
-    /**
-     * Identity of the host field this addon is attached to. Empty strings
-     * indicate the addon is rendered outside an active field context (rare).
-     * Use {@link isFieldBoundContext} or the `form !== null` check to
-     * narrow before relying on field identity.
-     */
-    readonly field: {
-        readonly key: string;
-        readonly type: string;
-    };
-    /**
-     * Current value of the host field at the time the action fires.
-     * `undefined` when the host field has no value yet (initial render before
-     * defaultValue resolution) or when the addon is rendered outside a field.
-     */
-    readonly value: TValue | undefined;
-}
-/**
- * Field-bound variant — the addon is attached to a real field and has a
- * working value-writer. The common case for `pi-button` / `mat-button` /
- * `bs-button` / `ion-button` inside an adapter input field.
- */
-interface FieldBoundAddonActionContext<TValue = unknown> extends AddonActionContextBase<TValue> {
-    /** Read-only view of the host field's tree — same view wrappers receive. */
-    readonly form: ReadonlyFieldTree<TValue>;
-    /** Push a new value into the host field. */
-    readonly setValue: (next: TValue) => void;
-}
-/**
- * Orphan variant — the addon is rendered outside any field component (rare;
- * happens when consumers compose `<df-addon-slot>` directly without a host
- * field). No writer is reachable; reading `value` may also yield `undefined`.
- */
-interface OrphanAddonActionContext<TValue = unknown> extends AddonActionContextBase<TValue> {
-    readonly form: null;
-    /** Always absent in the orphan variant — distinguishes the union members. */
-    readonly setValue?: undefined;
-}
-/** Context handed to inline addon actions and registered handler functions. */
-type AddonActionContext<TValue = unknown> = FieldBoundAddonActionContext<TValue> | OrphanAddonActionContext<TValue>;
-/** Type guard narrowing {@link AddonActionContext} to its field-bound variant. */
-declare function isFieldBoundContext<TValue>(ctx: AddonActionContext<TValue>): ctx is FieldBoundAddonActionContext<TValue>;
-/** Built-in preset actions shared across adapters. */
-type CommonAddonActionPreset = 'clear' | 'reset' | 'paste' | 'copy' | 'toggle-password-visibility';
-/** Module-augmentable registry of adapter-specific preset names. */
-interface DynamicFormAddonActionPresetRegistry {
-}
-/**
- * Union of every preset name an addon may reference — universal presets
- * plus any contributed via {@link DynamicFormAddonActionPresetRegistry}.
- */
-type AddonActionPreset = CommonAddonActionPreset | keyof DynamicFormAddonActionPresetRegistry | (string & {});
-/** Module-augmentable registry of user-defined named action handlers. */
-interface DynamicFormActionRegistry {
-}
-/**
- * Typed string handle to a registered action handler. The empty registry
- * resolves to `never`; augmenting `DynamicFormActionRegistry` populates the
- * union and unlocks autocomplete.
- */
-type RegisteredActionRef = keyof DynamicFormActionRegistry;
-
-/**
- * Map of named `TemplateRef`s collected by `<df-dynamic-form>` from
- * `<ng-template dfTemplate="...">` children projected into its content.
- * The directive selector is `dfTemplate` (see `DfTemplate`); the input
- * value is the name addons reference via `templateKey`.
- */
-declare const DF_FIELD_TEMPLATES: InjectionToken<Signal<ReadonlyMap<string, TemplateRef<unknown>>>>;
-
-interface FieldOption<T = unknown> {
-    label: DynamicText;
-    value: T;
-    disabled?: boolean;
-    [key: string]: unknown;
-}
-
-/** Injection token for form-level default wrappers. */
-declare const DEFAULT_WRAPPERS: InjectionToken<Signal<readonly WrapperConfig[] | undefined>>;
-/** Injection token for providing field signal context to mappers and components. */
-declare const FIELD_SIGNAL_CONTEXT: InjectionToken<FieldSignalContext<Record<string, unknown>>>;
-/** Throwing accessor for {@link FIELD_SIGNAL_CONTEXT}. */
-declare function injectFieldSignalContext<TModel extends Record<string, unknown> = Record<string, unknown>>(): FieldSignalContext<TModel>;
-/** Injection token for providing array context metadata to mappers and components. */
-declare const ARRAY_CONTEXT: InjectionToken<ArrayContext>;
-/** Injection token for providing group ancestry to mappers and components. */
-declare const GROUP_CONTEXT: InjectionToken<GroupContext>;
-/** Injection token for form-level default props. */
-declare const DEFAULT_PROPS: InjectionToken<Signal<Record<string, unknown> | undefined>>;
-/** Injection token for form-level default validation messages. */
-declare const DEFAULT_VALIDATION_MESSAGES: InjectionToken<Signal<ValidationMessages | undefined>>;
-/** Injection token for form-level options. */
-declare const FORM_OPTIONS: InjectionToken<Signal<FormOptions | undefined>>;
-
 /** Built-in field types provided by the dynamic form library. */
 declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
 
@@ -2562,9 +387,6 @@ interface LoggerConfigOptions {
  */
 declare function withLoggerConfig(config?: boolean | (() => boolean) | LoggerConfigOptions): DynamicFormFeature<'logger'>;
 
-/** Injection token for the dynamic forms logger. */
-declare const DynamicFormLogger: InjectionToken<Logger>;
-
 /** Console-based logger implementation. */
 declare class ConsoleLogger implements Logger {
     private readonly prefix;
@@ -2574,17 +396,6 @@ declare class ConsoleLogger implements Logger {
     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;
-}
-
 /**
  * Enables automatic form value attachment to all events dispatched through the EventBus.
  *
@@ -2599,30 +410,6 @@ declare class NoopLogger implements Logger {
  */
 declare function withEventFormValue(): DynamicFormFeature<'event-form-value'>;
 
-/**
- * Configuration for excluding field values from form submission output
- * based on their reactive state (hidden, disabled, readonly).
- */
-interface ValueExclusionConfig {
-    /**
-     * Whether to exclude the value of hidden fields from submission output.
-     *
-     * @remarks
-     * This does NOT affect HiddenField (`type: 'hidden'`) — those fields
-     * store values without UI and their `hidden()` state is always `false`.
-     */
-    readonly excludeValueIfHidden?: boolean;
-    /** Whether to exclude the value of disabled fields from submission output. */
-    readonly excludeValueIfDisabled?: boolean;
-    /** Whether to exclude the value of readonly fields from submission output. */
-    readonly excludeValueIfReadonly?: boolean;
-}
-/**
- * Fully resolved exclusion config with all properties required.
- * Produced by the 3-tier resolution: `field ?? form ?? global`.
- */
-type ResolvedValueExclusionConfig = Required<ValueExclusionConfig>;
-
 /**
  * Configures global value exclusion defaults for form submission output.
  *
@@ -2637,17 +424,6 @@ type ResolvedValueExclusionConfig = Required<ValueExclusionConfig>;
  */
 declare function withValueExclusionDefaults(config?: Partial<ValueExclusionConfig>): DynamicFormFeature<'value-exclusion'>;
 
-/** Configuration for when validation runs based on a field's reactive state. */
-interface ValidationExecutionConfig {
-    /**
-     * Whether validators run while a field is hidden (statically, via `hidden`
-     * logic, or because any ancestor is hidden).
-     */
-    readonly validateWhenHidden?: boolean;
-}
-/** Fully resolved validation execution config — every property defined. */
-type ResolvedValidationExecutionConfig = Required<ValidationExecutionConfig>;
-
 /**
  * Configures global validation execution defaults — when validators should run
  * relative to a field's reactive state.
@@ -2676,27 +452,6 @@ declare function withLegacyStatusClasses(): DynamicFormFeature<'legacy-status-cl
 /** Zero-cost type carrier used in wrapper registrations. */
 declare function wrapperProps<T>(): T;
 
-/** Input shape passed to a wrapper component via the `fieldInputs` input. */
-interface WrapperFieldInputs {
-    readonly key: string;
-    /** Field-type discriminant (mirrors `FieldDef.type`) — useful for kind-aware addons. */
-    readonly type?: string;
-    readonly label?: string;
-    readonly placeholder?: string;
-    readonly className?: string;
-    readonly props?: Record<string, unknown>;
-    readonly validationMessages?: Record<string, string>;
-    readonly defaultValidationMessages?: Record<string, string>;
-    readonly field?: ReadonlyFieldTree;
-    /**
-     * Write a value into the wrapped field's tree. Provided by `buildFieldInputs`
-     * when a `FieldTree` is present. Addons (e.g., `prime-button` presets) use this
-     * to mutate the host field; wrappers should treat the field as read-only.
-     */
-    readonly setValue?: (next: unknown) => void;
-    readonly [key: string]: unknown;
-}
-
 /**
  * Dispatcher component that renders an addon by looking up its `kind` in
  * `ADDON_KIND_REGISTRY` and instantiating the registered component.
@@ -2914,9 +669,6 @@ interface FieldAddonSupportEntry {
  */
 declare function injectFieldsSupportingAddons(): FieldAddonSupportEntry[];
 
-/** Normalises a {@link DynamicValue} into a `Signal<T>`. */
-declare function resolveDynamicValue<T>(value: DynamicValue<T> | undefined, fallback: T, injector?: Injector): Signal<T>;
-
 /** Register a custom addon kind with the form. */
 declare function withCustomAddon<T extends BaseAddon>(definition: AddonKindDefinition<T>): DynamicFormFeature<'addons'>;
 
@@ -3069,69 +821,7 @@ declare function logAddonWarnings(warnings: readonly AddonWarning[], logger?: Lo
  * outside Angular's injector — build-time linters, MCP-side checks, CLI
  * scripts.
  */
-declare function sanitizeFormConfigPure(config: FormConfig, fieldRegistry: ReadonlyMap<string, FieldTypeDefinition>, kindRegistry: ReadonlyMap<string, AddonKindDefinition>, options?: SanitizeFormConfigOptions): SanitizedFormConfig;
-
-interface FieldWithValidation {
-    readonly required?: boolean;
-    readonly email?: boolean;
-    readonly min?: number;
-    readonly max?: number;
-    readonly minLength?: number;
-    readonly maxLength?: number;
-    readonly pattern?: string | RegExp;
-    readonly validators?: ValidatorConfig[];
-    readonly validationMessages?: ValidationMessages;
-    readonly logic?: LogicConfig[];
-    /** Shorthand for simple computed/derived fields. */
-    readonly derivation?: string;
-    readonly schemas?: SchemaApplicationConfig[];
-}
-
-/**
- * Supported primitive value types for form fields.
- * This type represents all possible value types that can be used in form fields.
- */
-type ValueType = string | number | boolean | Date | object | unknown[];
-interface BaseValueField<TProps, TValue, TMeta extends FieldMeta = FieldMeta, TNullable extends boolean = false> extends FieldDef<TProps, TMeta>, FieldWithValidation {
-    value?: TNullable extends true ? TValue | null : TValue;
-    /**
-     * Placeholder text displayed when the field is empty.
-     * Supports static strings, Observables, and Signals for dynamic content.
-     */
-    placeholder?: DynamicText;
-    required?: boolean;
-    /**
-     * Whether the field accepts `null` as a valid value.
-     *
-     * @default false
-     */
-    nullable?: TNullable;
-}
-declare function isValueField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseValueField<TProps, ValueType, TMeta, boolean>;
-type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'valueType' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'derivation' | 'schemas' | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons';
-type ValueFieldComponent<T extends BaseValueField<Record<string, unknown> | unknown, unknown, FieldMeta, boolean>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
-
-interface BaseCheckedField<TProps, TMeta extends FieldMeta = FieldMeta, TNullable extends boolean = false> extends FieldDef<TProps, TMeta>, FieldWithValidation {
-    value?: TNullable extends true ? boolean | null : boolean;
-    /**
-     * Placeholder text displayed when the field is empty.
-     * Supports static strings, Observables, and Signals for dynamic content.
-     */
-    placeholder?: DynamicText;
-    required?: boolean;
-    /**
-     * Whether the field accepts `null` as a valid value.
-     *
-     * @default false
-     */
-    nullable?: TNullable;
-}
-declare function isCheckedField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseCheckedField<TProps, TMeta, boolean>;
-type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons';
-type CheckedFieldComponent<T extends BaseCheckedField<Record<string, unknown> | unknown, FieldMeta, boolean>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
-
-declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
-declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
+declare function sanitizeFormConfigPure(config: FormConfig, fieldRegistry: ReadonlyMap<string, _ng_forge_dynamic_forms_internal.FieldTypeDefinition>, kindRegistry: ReadonlyMap<string, _ng_forge_dynamic_forms_internal.AddonKindDefinition>, options?: SanitizeFormConfigOptions): SanitizedFormConfig;
 
 declare class SubmitEvent implements FormEvent {
     readonly type: "submit";
@@ -3358,28 +1048,6 @@ declare function arrayEvent(arrayKey: string): {
     move: (from: number, to: number) => MoveArrayItemEvent;
 };
 
-/** Context for token resolution in event args */
-interface TokenContext {
-    /** Current field key */
-    key?: string;
-    /** Array index if field is inside an array */
-    index?: number;
-    /** Parent array field key if field is inside an array */
-    arrayKey?: string;
-    /** Current form value for complex indexing */
-    formValue?: unknown;
-    /** Template for array item creation */
-    template?: unknown;
-}
-/**
- * Resolves special tokens in event arguments to their actual values
- *
- * @param args - Array of arguments that may contain tokens
- * @param context - Context object containing token values
- * @returns Array with resolved values
- */
-declare function resolveTokens(args: readonly (string | number | boolean | null | undefined)[], context: TokenContext): (string | number | boolean | null | undefined | unknown)[];
-
 /**
  * Context object for array item operations (add/remove)
  * Provides the necessary information to resolve tokens in array item event arguments
@@ -3419,391 +1087,5 @@ declare function createField<T extends AvailableFieldTypes>(type: T, config: Omi
 /** Shorthand alias for createField */
 declare const field: typeof createField;
 
-/** Base error class for all Dynamic Forms errors. */
-declare class DynamicFormError extends Error {
-    private static readonly PREFIX;
-    constructor(message: string);
-}
-
-/**
- * Builds base input properties from a field definition.
- *
- * @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>, defaultProps?: Record<string, unknown>): Record<string, unknown>;
-/**
- * Base field mapper that extracts common field properties into component inputs.
- *
- * @param fieldDef The field definition to map
- * @returns Signal containing Record of input names to values
- */
-declare function baseFieldMapper(fieldDef: FieldDef<unknown>): Signal<Record<string, unknown>>;
-
-/** Maps a row field definition to container component inputs. */
-declare function rowFieldMapper(fieldDef: RowField): Signal<Record<string, unknown>>;
-
-/**
- * Maps a group field definition to component inputs.
- *
- * @param fieldDef The group field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
-declare function groupFieldMapper(fieldDef: GroupField): Signal<Record<string, unknown>>;
-
-/**
- * Maps an array field definition to component inputs.
- *
- * @param fieldDef The array field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
-declare function arrayFieldMapper(fieldDef: ArrayField): Signal<Record<string, unknown>>;
-
-/**
- * Maps a page field definition to component inputs.
- *
- * @param fieldDef The page field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
-declare function pageFieldMapper(fieldDef: PageField): Signal<Record<string, unknown>>;
-
-/**
- * Maps a text field definition to component inputs.
- *
- * @param fieldDef The text field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
-declare function textFieldMapper(fieldDef: TextField): Signal<Record<string, unknown>>;
-
-/**
- * Maps a container field definition to component inputs.
- *
- * @param fieldDef The container field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
-declare function containerFieldMapper(fieldDef: ContainerField): Signal<Record<string, unknown>>;
-
-/**
- * Converts DynamicText (string | Observable | Signal) to Observable<string>
- * Unifies all three types into a consistent Observable stream
- *
- * @param value - The dynamic text value to convert
- * @param injector - Optional injector for signal conversion
- * @returns Observable<string> - The value as an observable stream
- */
-declare function dynamicTextToObservable(value: DynamicText | undefined, injector?: Injector): Observable<string>;
-
-/**
- * Applies meta attributes to a DOM element and tracks which attributes were applied.
- *
- * @param element - The DOM element to apply attributes to
- * @param meta - The meta object containing attributes to apply
- * @param previouslyApplied - Set of attribute names that were previously applied
- * @returns A new Set containing the attribute names that were applied
- */
-declare function applyMetaToElement(element: Element, meta: FieldMeta | undefined, previouslyApplied: Set<string>): Set<string>;
-
-/**
- * Wraps a `Resource` so that the previous resolved value is preserved while the resource
- * is loading or reloading. This prevents UI flicker when params change and a new request
- * is in-flight — the consumer sees the stale value with a `loading`/`reloading` status
- * instead of `undefined`.
- */
-declare function withPreviousValue<T>(input: Resource<T>): Resource<T>;
-
-/**
- * Pipe that handles dynamic text resolution with support for static strings,
- * Observables, and Signals.
- */
-declare class DynamicTextPipe implements PipeTransform {
-    private readonly injector;
-    /**
-     * Transforms dynamic text input into a resolved string value
-     *
-     * @param value - The dynamic text value to resolve
-     * @returns The resolved string value as an Observable
-     */
-    transform(value: DynamicText | undefined): Observable<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicTextPipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DynamicTextPipe, "dynamicText", true>;
-}
-
-/** Container component for rendering nested form groups. */
-declare class GroupFieldComponent<TModel extends Record<string, unknown> = Record<string, unknown>> {
-    private readonly destroyRef;
-    private readonly fieldRegistry;
-    private readonly parentFieldSignalContext;
-    private readonly parentGroupContext;
-    private readonly injector;
-    protected readonly environmentInjector: EnvironmentInjector;
-    private readonly eventBus;
-    private readonly logger;
-    private readonly fieldProcessors;
-    field: _angular_core.InputSignal<GroupField<readonly _ng_forge_dynamic_forms.GroupAllowedChildren[]>>;
-    key: _angular_core.InputSignal<string>;
-    className: _angular_core.InputSignal<string | undefined>;
-    hidden: _angular_core.InputSignal<boolean>;
-    readonly hostClasses: _angular_core.Signal<string>;
-    private readonly rawFieldRegistry;
-    private readonly formSetup;
-    readonly defaultValues: _angular_core.WritableSignal<Record<string, unknown>>;
-    /**
-     * Entity computed from parent value, group key, and defaults.
-     * Uses deep equality check to prevent unnecessary updates when
-     * object spread creates new references with identical values.
-     */
-    private readonly entity;
-    private readonly form;
-    readonly formValue: _angular_core.Signal<{}>;
-    readonly valid: _angular_core.Signal<boolean>;
-    readonly invalid: _angular_core.Signal<boolean>;
-    readonly dirty: _angular_core.Signal<boolean>;
-    readonly touched: _angular_core.Signal<boolean>;
-    readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithFieldTree[]>;
-    readonly disabled: _angular_core.Signal<boolean>;
-    private readonly nestedFieldTree;
-    private readonly groupFieldSignalContext;
-    /**
-     * Group context propagated to descendants — carries the dot-separated path of
-     * group ancestors so child fields can scope their DOM IDs (issue #401).
-     * Reactive via `computed()`: a nested group composes its path from the parent
-     * context signal + its own key, so the chain stays consistent if either changes.
-     */
-    private readonly groupContext;
-    private readonly groupInjector;
-    readonly validityChange: _angular_core.OutputRef<boolean>;
-    readonly dirtyChange: _angular_core.OutputRef<boolean>;
-    readonly submitted: _angular_core.OutputRef<SubmitEvent>;
-    private readonly fieldsSource;
-    protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
-    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; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, { "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; }, never, never, true, never>;
-}
-
-/** A single field within a resolved array item. */
-interface ResolvedArrayItemField {
-    /** Field key (used for tracking and test IDs). */
-    key: string;
-    /** Original field definition — used by DfFieldOutlet to resolve wrappers. */
-    fieldDef: FieldDef<unknown>;
-    /** The loaded component type. */
-    component: Type<unknown>;
-    /** Injector providing ARRAY_CONTEXT and FIELD_SIGNAL_CONTEXT. */
-    injector: Injector;
-    /** Inputs signal for DfFieldOutlet — evaluated in template for reactivity. */
-    inputs: Signal<Record<string, unknown>>;
-    /** Whether required mapped inputs are available for safe component instantiation. */
-    renderReady: Signal<boolean>;
-    /**
-     * Whether the array-item field is currently hidden — mirrors `ResolvedField.hidden`
-     * so the same `@if (!field.hidden())` template gate works for top-level and
-     * array-item fields.
-     */
-    hidden: Signal<boolean>;
-}
-/**
- * Resolved array item ready for declarative rendering with ngComponentOutlet.
- * Each item has a stable unique ID and a linkedSignal-based index that
- * automatically updates when items are added/removed.
- * Supports multiple fields per array item (e.g., name + email without a wrapper).
- */
-interface ResolvedArrayItem {
-    /** Unique identifier for this item (stable across position changes). */
-    id: string;
-    /** All fields to render for this array item. */
-    fields: ResolvedArrayItemField[];
-}
-
-/** Container component for rendering dynamic arrays of fields. */
-declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Record<string, unknown>> {
-    private readonly destroyRef;
-    private readonly fieldRegistry;
-    private readonly parentFieldSignalContext;
-    private readonly parentInjector;
-    protected readonly environmentInjector: EnvironmentInjector;
-    private readonly eventBus;
-    private readonly logger;
-    private readonly arrayItemRegistry;
-    private readonly slot;
-    /** Bound id-generator reference threaded to `resolveArrayItem` so callsites stay terse. */
-    private readonly generateItemId;
-    field: _angular_core.InputSignal<ArrayField<readonly ArrayItemDefinition[]>>;
-    key: _angular_core.InputSignal<string>;
-    className: _angular_core.InputSignal<string | undefined>;
-    hidden: _angular_core.InputSignal<boolean>;
-    readonly hostClasses: Signal<string>;
-    private readonly rawFieldRegistry;
-    /**
-     * Gets the auto-remove button FieldDef from normalization metadata.
-     * Set by simplified array normalization for primitive arrays with remove buttons.
-     * The button is rendered alongside each item without wrapping in a row,
-     * preserving flat primitive form values.
-     */
-    private readonly autoRemoveButton;
-    /**
-     * For primitive array items, the key of the value field template (e.g., 'value').
-     * Used to wrap the FormControl in the item context so getFieldTree(key) works.
-     * Returns undefined for object arrays (FormGroup items have natural child navigation).
-     */
-    private readonly primitiveFieldKey;
-    /**
-     * Normalized item templates WITHOUT auto-remove button appended.
-     * Each element is normalized to an array: single FieldDef → [FieldDef], array stays as-is.
-     */
-    private readonly rawItemTemplates;
-    /**
-     * Resolves the effective fallback template for this array — used when the form
-     * value contains an item with no registered template (i.e., items that were
-     * neither added via event handlers nor covered by a positional entry in `fields`).
-     */
-    private readonly fallbackTemplate;
-    /**
-     * Gets the item templates (field definitions) for the array.
-     * Each element can be either:
-     * - A single FieldDef (primitive item) - normalized to [FieldDef]
-     * - An array of FieldDefs (object item) - used as-is
-     */
-    private readonly itemTemplates;
-    private readonly arrayFieldTrees;
-    private readonly resolvedItemsSignal;
-    private readonly fsm;
-    /**
-     * Map of item IDs to their current positions. O(1) lookup vs O(n) indexOf().
-     * Used by child linkedSignals to reactively track their position in the array.
-     */
-    private readonly itemPositionMap;
-    /** Read-only view of resolved items for template consumption. */
-    readonly resolvedItems: Signal<ResolvedArrayItem[]>;
-    private readonly allResolvedFieldsRenderReady;
-    /**
-     * Whether the array has reached its configured maxLength.
-     * Exposed as a public signal so add-button components can bind [disabled]="atMaxLength()".
-     */
-    readonly atMaxLength: Signal<boolean>;
-    /**
-     * Caches the result of appending the auto-remove button to template arrays.
-     * Keyed by template array reference — cache hits occur during recreate/resolution
-     * operations where stored template references are reused. Add operations via
-     * handleAddFromEvent always create a fresh `[...template]` copy (line ~277),
-     * so each add is a cache miss by design (the spread is needed for mutability).
-     */
-    private readonly autoRemoveCache;
-    constructor();
-    private setupEffects;
-    private setupEventHandlers;
-    /**
-     * Handles add operations from events (append, prepend, insert).
-     * Creates resolved items FIRST, then updates form value.
-     * This ensures prepend/insert work correctly - differential update sees "none"
-     * because resolved items count already matches the new array length.
-     */
-    private handleAddFromEvent;
-    private performDifferentialUpdate;
-    private resolveAllItems;
-    private appendItems;
-    /** Creates an observable that resolves a single array item. */
-    private createResolveItemObservable;
-    /**
-     * Appends the auto-remove button to a templates array for rendering.
-     * The button is added for visual rendering only — it doesn't affect the form schema.
-     * Original templates are stored in templateRegistry WITHOUT the remove button,
-     * so this method is called during resolution to add it dynamically.
-     */
-    private withAutoRemove;
-    /**
-     * Handles move operations — reorders an existing item without destroying it.
-     * Updates resolvedItems and form value atomically. Since the array length
-     * doesn't change, `determineDifferentialOperation` returns 'none' and no
-     * recreate is triggered. The `@for` loop tracks by `item.id`, so Angular
-     * moves the DOM node instead of destroying/recreating. The `itemPositionMap`
-     * computed auto-recomputes, propagating new indices to child linkedSignals.
-     */
-    private moveItem;
-    /**
-     * Handles remove operations from events (pop, shift, removeAt).
-     * Updates resolvedItems FIRST, then form value - this ensures differential
-     * update sees "none" (lengths match) and avoids unnecessary recreates.
-     * Remaining items' linkedSignal indices auto-update via itemPositionMap.
-     */
-    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; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/** Layout container that wraps child fields with UI chrome. */
-declare class ContainerFieldComponent {
-    private readonly destroyRef;
-    private readonly fieldRegistry;
-    private readonly injector;
-    protected readonly environmentInjector: EnvironmentInjector;
-    private readonly eventBus;
-    private readonly logger;
-    private readonly wrapperAutoAssociations;
-    private readonly defaultWrappersSignal;
-    private readonly childrenTpl;
-    private readonly wrapperContainer;
-    field: _angular_core.InputSignal<ContainerField<readonly _ng_forge_dynamic_forms.ContainerAllowedChildren[], readonly _ng_forge_dynamic_forms.WrapperConfig[]>>;
-    key: _angular_core.InputSignal<string>;
-    className: _angular_core.InputSignal<string | undefined>;
-    hidden: _angular_core.InputSignal<boolean>;
-    readonly hostClasses: _angular_core.Signal<string>;
-    readonly disabled: _angular_core.Signal<boolean>;
-    private readonly rawFieldRegistry;
-    private readonly fieldsSource;
-    protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
-    private readonly wrappers;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContainerFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContainerFieldComponent, "div[container-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Native JavaScript utility functions to replace lodash-es
- * These are simple implementations for common object manipulation patterns
- */
-/**
- * Performs a deep equality comparison between two values.
- *
- * @param a - First value
- * @param b - Second value
- * @returns true if values are deeply equal
- */
-declare function isEqual(a: unknown, b: unknown): boolean;
-/**
- * Creates a new object without the specified keys
- * Native replacement for lodash omit()
- *
- * @param obj - Source object
- * @param keys - Keys to omit
- * @returns New object without specified keys
- */
-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
- *
- * @param message - Message template with {{param}} placeholders
- * @param error - Validation error containing parameter values
- * @returns Message with interpolated parameters
- */
-declare function interpolateParams(message: string, error: ValidationError): string;
-
-/** Registry service that provides access to the root form and its values. */
-declare class RootFormRegistryService {
-    readonly formValue: Signal<Record<string, unknown>>;
-    readonly rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>;
-    constructor(formValue: Signal<Record<string, unknown>>, rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>);
-}
-
-/**
- * Injection token for configuring the initialization timeout in milliseconds.
- * Defaults to 10 seconds. When the timeout is reached, a warning is logged
- * and (initialized) emits true as a best-effort fallback.
- */
-declare const INITIALIZATION_TIMEOUT_MS: InjectionToken<number>;
-
-export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_KIND_COMPONENT_CACHE, ADDON_KIND_DEFINITIONS, ADDON_KIND_REGISTRY, ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, ContainerFieldComponent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DF_FIELD_TEMPLATES, DfAddonSlot, DfTemplate, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, EventDispatcher, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GROUP_CONTEXT, GroupFieldComponent, INITIALIZATION_TIMEOUT_MS, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, RootFormRegistryService, ShiftArrayItemEvent, SubmitEvent, TemplateAddonComponent, TextAddonComponent, WRAPPER_REGISTRY, applyMetaToElement, applyValidator, applyValidators, arrayEvent, arrayFieldMapper, baseFieldMapper, buildBaseInputs, containerFieldMapper, createField, createWrappers, dynamicTextToObservable, evaluateNonFieldDisabled, evaluateNonFieldHidden, field, formConfig, formatAddonWarning, getArrayLength, groupFieldMapper, hasFormValue, injectAddonKindRegistry, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isArrayField, isCheckedField, isContainerField, isContainerTypedField, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, isWrapperTypeDefinition, isWrappersBundle, logAddonWarnings, omit, pageFieldMapper, provideAddonActions, provideDynamicForm, resolveDynamicValue, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, runPresetAction, sanitizeFormConfig, sanitizeFormConfigPure, textFieldMapper, toReadonlyFieldTree, validateFieldAddons, walkAndValidateAddons, withCustomAddon, withEventFormValue, withLegacyStatusClasses, withLoggerConfig, withPreviousValue, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps, writeToFieldValue };
-export type { AddonActionContext, AddonActionHandler, AddonActionPreset, AddonActionsFeature, AddonKindDefinition, AddonKindSchema, AddonShapeValidator, AddonSlot, AddonWarning, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, ArrayItemDefinitionTemplate, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldAddonSupport, FieldAddonSupportEntry, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, InferFormValue$1 as InferFormValue, InferWrapperRegistry, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, OrphanAddonActionContext, PageAllowedChildren, PageField, PresetCollaborators, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SanitizeFormConfigOptions, SanitizedFormConfig, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals, WrapperConfig, WrapperFieldInputs, WrapperRegistration, WrapperTypeDefinition, WrappersBundle };
+export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_KIND_COMPONENT_CACHE, ADDON_KIND_DEFINITIONS, AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DfAddonSlot, DfTemplate, DynamicForm, EventDispatcher, FormClearEvent, FormResetEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, SubmitEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createField, createWrappers, field, formConfig, formatAddonWarning, injectAddonKindRegistry, injectFieldsSupportingAddons, isWrappersBundle, logAddonWarnings, provideAddonActions, provideDynamicForm, runPresetAction, sanitizeFormConfig, sanitizeFormConfigPure, validateFieldAddons, walkAndValidateAddons, withCustomAddon, withEventFormValue, withLegacyStatusClasses, withLoggerConfig, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
+export type { AddonActionHandler, AddonActionsFeature, AddonWarning, ArrayItemContext, ArrayItemDefinitionTemplate, ExtractFieldDefs, ExtractFormValue, FieldAddonSupportEntry, InferWrapperRegistry, PresetCollaborators, SanitizeFormConfigOptions, SanitizedFormConfig, WrapperRegistration, WrappersBundle };