@ng-forge/dynamic-forms 1.0.0-rc.1 → 1.0.0-rc.2

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

@@ -1,10 +1,190 @@
+import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
+import * as i0 from '@angular/core';
+import { Signal, Type, ResourceRef, ViewContainerRef, InjectionToken, WritableSignal, Injector, TemplateRef, PipeTransform, Resource } from '@angular/core';
 import { Observable, OperatorFunction } from 'rxjs';
 import { FieldContext, TreeValidationResult, ValidationError as ValidationError$1, FieldTree, ReadonlyFieldState, LogicFn, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
-import * as i0 from '@angular/core';
-import { Signal, ResourceRef, Injector, WritableSignal, InjectionToken, Type, ViewContainerRef, TemplateRef, PipeTransform, Resource } from '@angular/core';
-import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
 import { FormSchema } from '@ng-forge/dynamic-forms/schema';
 
+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 type 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 types. */
+    readonly disabled?: DynamicValue<boolean>;
+}
+/** Module-augmentable registry of addon types. */
+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 type: 'text';
+    readonly text: DynamicText;
+}
+/** Renders a named `<ng-template>` projected into the host `<df-dynamic-form>`. */
+interface TemplateAddon extends BaseAddon {
+    readonly type: '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 type when the
+ * config originated from JSON (set via `sanitizeFormConfig({ source: 'json' })`).
+ */
+interface ComponentAddon extends BaseAddon {
+    readonly type: '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];
+} & {};
+
+/** 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>>>;
+
 /**
  * Interface for dynamic forms logger implementations.
  * Allows custom logging integrations (Sentry, DataDog, etc.)
@@ -257,370 +437,438 @@ interface OrCondition {
 /** Discriminated union of all conditional expression types. */
 type ConditionalExpression = FieldValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
 
-/** 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
+ * 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 BaseStateLogicConfig {
-    /** Logic type identifier for field state. */
-    type: StateLogicType;
-    /** Condition that determines when this logic applies. */
-    condition: ConditionalExpression | boolean | FormStateCondition;
+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;
 }
+
 /**
- * State logic that evaluates immediately on change (default).
- *
- * @internal
+ * 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 ImmediateStateLogicConfig extends BaseStateLogicConfig {
+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;
     /**
-     * Trigger for immediate evaluation.
-     *
-     * @default 'onChange'
+     * Logic configurations for conditional row visibility.
+     * Only 'hidden' type logic is supported for rows.
      */
-    trigger?: 'onChange';
-    /** Not allowed for onChange trigger */
-    debounceMs?: never;
+    readonly logic?: ContainerLogicConfig[];
 }
+/** Type guard for RowField with proper type narrowing */
+declare function isRowField(field: FieldDef<any>): field is RowField;
+type RowComponent = FieldComponent<RowField<RowAllowedChildren[]>>;
+
 /**
- * State logic that evaluates after a debounce period.
- *
- * @internal
+ * 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 DebouncedStateLogicConfig extends BaseStateLogicConfig {
+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;
     /**
-     * Trigger for debounced evaluation.
-     * Evaluates after the value has stabilized for the debounce duration.
+     * Logic configurations for conditional group visibility.
+     * Only 'hidden' type logic is supported for groups.
      */
-    trigger: 'debounced';
-    /**
-     * Debounce duration in milliseconds.
-     *
-     * @default 500
-     */
-    debounceMs?: number;
+    readonly logic?: ContainerLogicConfig[];
 }
-/** Configuration for conditional field state logic. */
-type StateLogicConfig = ImmediateStateLogicConfig | DebouncedStateLogicConfig;
-/** Trigger timing for when logic is evaluated. */
-type LogicTrigger = 'onChange' | 'debounced';
-/**
- * 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;
+/** Type guard for GroupField with proper type narrowing */
+declare function isGroupField(field: FieldDef<any>): field is GroupField;
+type GroupComponent<T extends GroupAllowedChildren[]> = FieldComponent<GroupField<T>>;
+
+/** 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;
     /**
-     * When true, the derivation stops running after the user manually
-     * edits the target field.
+     * 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.
      */
-    stopOnUserOverride?: boolean;
+    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;
     /**
-     * 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.
+     * Logic configurations for conditional container visibility.
+     * Only 'hidden' type logic is supported for containers.
      */
-    reEngageOnDependencyChange?: boolean;
+    readonly logic?: ContainerLogicConfig[];
 }
+/** Type guard for ContainerField with proper type narrowing. */
+declare function isGenericContainerField(field: FieldDef<any>): field is ContainerField;
+type ContainerComponent = FieldComponent<ContainerField<ContainerAllowedChildren[]>>;
+
 /**
- * Trigger variants for derivation timing.
- *
- * @internal
+ * Type constraints for field nesting rules
+ * These ensure that container fields can only contain valid child field types
  */
-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
+ * Fields that are allowed as children of Page fields
+ * Pages can contain: rows, groups, arrays, and leaf fields (but NOT other pages)
  */
-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;
-}
+type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
 /**
- * Shared fields for both branches of {@link AsyncFunctionDerivationBase}.
- *
- * @internal
+ * Fields that are allowed as children of Group fields
+ * Groups can contain: rows, arrays, and leaf fields (but NOT pages or other groups)
  */
-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;
-}
+type GroupAllowedChildren = LeafFieldTypes | RowField | ArrayField | SimplifiedArrayField | ContainerField;
 /**
- * Base for async function derivations. `source: 'asyncFunction'` is required.
- * TypeScript enforces `dependsOn` at the type level, and `asyncFunctionName` /
- * `asyncFn` are mutually exclusive (XOR).
- *
- * @internal
+ * 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 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;
-});
+type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField | ContainerField;
 /**
- * Base for expression derivations.
- *
- * @internal
+ * 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.
  */
-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;
-}
+type ContainerAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
 /**
- * Base for value derivations.
- *
- * @internal
+ * Row is a synthetic field type that resolves to a Container at runtime, so
+ * it accepts the same children as a Container.
  */
-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;
-}
+type RowAllowedChildren = ContainerAllowedChildren;
+
 /**
- * Shared fields for both branches of {@link FunctionDerivationBase}.
- *
- * @internal
+ * 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, ... }`.
  */
-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;
-}
+type ArrayItemTemplate = readonly ArrayAllowedChildren[];
 /**
- * Base for custom sync function derivations. `functionName` and `fn` are
- * mutually exclusive (XOR).
- *
- * @internal
+ * 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 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;
-});
+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;
+}
 /**
- * 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 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).
  */
-type DebouncedAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & DebouncedDerivationTrigger;
+declare function isArrayField(field: FieldDef<any>): field is ArrayField;
+type ArrayComponent<T extends ArrayItemTemplate[]> = FieldComponent<ArrayField<T>>;
+/** 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;
+}
 /**
- * Expression derivation that evaluates immediately on change (default).
- *
- * @internal
+ * Type guard for SimplifiedArrayField.
+ * Checks for `type: 'array'` with a `template` property (discriminant from full ArrayField).
  */
-type OnChangeExpressionDerivationLogicConfig = ExpressionDerivationBase & ImmediateDerivationTrigger;
+declare function isSimplifiedArrayField(field: FieldDef<any>): field is SimplifiedArrayField;
+
 /**
- * Expression derivation that evaluates after a debounce period.
- *
- * @internal
+ * Scalar types supported by hidden fields.
+ * These are the primitive value types that can be stored.
  */
-type DebouncedExpressionDerivationLogicConfig = ExpressionDerivationBase & DebouncedDerivationTrigger;
+type HiddenScalar = string | number | boolean;
 /**
- * Value derivation that evaluates immediately on change (default).
- *
- * @internal
+ * All value types supported by hidden fields.
+ * Supports both scalar values and arrays of scalars for storing
+ * multiple IDs or similar data.
  */
-type OnChangeValueDerivationLogicConfig = ValueDerivationBase & ImmediateDerivationTrigger;
+type HiddenValue = HiddenScalar | HiddenScalar[];
 /**
- * Value derivation that evaluates after a debounce period.
+ * Hidden field definition for storing values without rendering UI.
  *
- * @internal
+ * @typeParam TValue - The type of value stored (must be HiddenValue compatible)
  */
-type DebouncedValueDerivationLogicConfig = ValueDerivationBase & DebouncedDerivationTrigger;
+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;
+}
 /**
- * Function derivation that evaluates immediately on change (default).
+ * Type guard to check if a field is a hidden field.
  *
- * @internal
+ * @param field - The field to check
+ * @returns True if the field is a HiddenField
  */
-type OnChangeFunctionDerivationLogicConfig = FunctionDerivationBase & ImmediateDerivationTrigger;
+declare function isHiddenField(field: FieldDef<unknown>): field is HiddenField;
+
 /**
- * Function derivation that evaluates after a debounce period.
- *
- * @internal
+ * 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
  */
-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';
-/** Configuration for derivation debug logging. */
-interface DerivationLogConfig {
-    /** Log level for derivation debugging. Defaults to 'none'. */
-    level: DerivationLogLevel;
+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;
 /**
- * Creates the default derivation log configuration.
+ * Validates that a page field doesn't contain nested page fields
  *
- * @returns Default DerivationLogConfig
+ * @param pageField The page field to validate
+ * @returns true if valid (no nested pages), false otherwise
  */
-declare function createDefaultDerivationLogConfig(): DerivationLogConfig;
+declare function validatePageNesting(pageField: PageField): boolean;
+
 /**
- * Checks if logging should occur at the specified level.
- *
- * @param config - Current log configuration
- * @param minLevel - Minimum level required for logging
- * @returns True if logging should occur
+ * Helper type to convert union to intersection.
+ * Uses `U extends U` to trigger distributive conditional type behavior.
  */
-declare function shouldLog(config: DerivationLogConfig, minLevel: 'summary' | 'verbose'): boolean;
+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];
 /**
- * Type guard to check if a condition is a FormStateCondition.
- *
- * @param condition - The condition to check
- * @returns true if the condition is a FormStateCondition
+ * 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`.
  */
-declare function isFormStateCondition(condition: StateLogicConfig['condition'] | DerivationLogicConfig['condition']): condition is FormStateCondition;
+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;
 /**
- * Type guard to check if a logic config is a StateLogicConfig.
- *
- * @param config - The logic config to check
- * @returns true if the config is for field state logic
+ * 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`.
  */
-declare function isStateLogicConfig(config: LogicConfig): config is StateLogicConfig;
+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>;
 /**
- * Type guard to check if a logic config is a DerivationLogicConfig.
- *
- * @param config - The logic config to check
- * @returns true if the config is for value derivation
+ * 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`.
  */
-declare function isDerivationLogicConfig(config: LogicConfig): config is DerivationLogicConfig;
+type InferValueType<T, V> = T extends {
+    nullable: true;
+} ? ResolveBaseValueType<T, V> | null : ResolveBaseValueType<T, V>;
 /**
- * Type guard to check if a derivation config targets a property rather than the field value.
- *
- * @param config - The derivation logic config to check
- * @returns true if the config has a targetProperty (property derivation)
+ * Make type optional if field is not required.
+ * Hidden fields are never optional since they require a value property.
  */
-declare function hasTargetProperty(config: DerivationLogicConfig): config is DerivationLogicConfig & {
-    targetProperty: string;
-};
-
+type MaybeOptional<T, V> = T extends {
+    type: 'hidden';
+} ? V : T extends {
+    required: true;
+} ? V : V | undefined;
 /**
- * Custom validator function signature using Angular's public FieldContext API
- *
- * @template TValue The type of value stored in the field being validated
+ * 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 CustomValidator<TValue = unknown> = (ctx: FieldContext<TValue>, params?: Record<string, unknown>) => ValidationError$1 | ValidationError$1[] | null;
+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>;
 /**
- * Async custom validator configuration using Angular's resource-based API
- *
+ * 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<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
@@ -797,629 +1045,753 @@ type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncVal
 /** Type guard to distinguish function-based HTTP validators from declarative ones. */
 declare function isFunctionHttpValidator(config: FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig): config is FunctionHttpValidatorConfig;
 
-/** 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[];
-}
-
-/** Context for cross-field detection, providing access to function scope information. */
-interface CrossFieldDetectionContext {
-    /**
-     * Lookup function to get the scope of a registered custom function.
-     *
-     * @param functionName The name of the custom function
-     * @returns The function's scope, or undefined if not registered
-     */
-    getFunctionScope?: (functionName: string) => CustomFunctionScope | undefined;
-}
+/** 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';
 /**
- * Detects if a ConditionalExpression references other fields (cross-field).
+ * Base configuration for conditional field state logic.
  *
- * @param expr The conditional expression to analyze
- * @param context Optional context providing function scope lookup
- * @returns true if the expression references other fields
+ * @internal
  */
-declare function isCrossFieldExpression(expr: ConditionalExpression | boolean | FormStateCondition | undefined, context?: CrossFieldDetectionContext): boolean;
+interface BaseStateLogicConfig {
+    /** Logic type identifier for field state. */
+    type: StateLogicType;
+    /** Condition that determines when this logic applies. */
+    condition: ConditionalExpression | boolean | FormStateCondition;
+}
 /**
- * Extracts field dependencies from a ConditionalExpression.
+ * State logic that evaluates immediately on change (default).
  *
- * @param expr The conditional expression to analyze
- * @returns Array of field keys that this expression depends on
- */
-declare function extractExpressionDependencies(expr: ConditionalExpression | boolean | undefined): string[];
-/**
- * Extracts field names from a JavaScript expression string.
- * Handles both dot notation (formValue.field) and bracket notation (formValue['field']).
+ * @internal
  */
-declare function extractStringDependencies(expression: string): string[];
+interface ImmediateStateLogicConfig extends BaseStateLogicConfig {
+    /**
+     * Trigger for immediate evaluation.
+     *
+     * @default 'onChange'
+     */
+    trigger?: 'onChange';
+    /** Not allowed for onChange trigger */
+    debounceMs?: never;
+}
 /**
- * Detects if a custom validator configuration references formValue (cross-field validation).
+ * State logic that evaluates after a debounce period.
  *
- * @param config The custom validator configuration to check
- * @returns true if the validator references formValue
+ * @internal
  */
-declare function isCrossFieldValidator(config: CustomValidatorConfig): boolean;
+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;
+/** Trigger timing for when logic is evaluated. */
+type LogicTrigger = 'onChange' | 'debounced';
 /**
- * Detects if a built-in validator has a dynamic expression that references formValue.
+ * Shared fields that appear on all derivation logic config variants.
  *
- * @param config The validator configuration to check
- * @returns true if the validator has a cross-field dynamic expression
+ * @internal
  */
-declare function isCrossFieldBuiltInValidator(config: ValidatorConfig): boolean;
-/** Checks if a validator uses Angular's resource API (validateHttp / validateAsync). */
-declare function isResourceBasedValidator(config: ValidatorConfig): boolean;
+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;
+}
 /**
- * Detects if a validator's `when` condition is cross-field.
+ * Trigger variants for derivation timing.
  *
- * @param config The validator configuration to check
- * @param context Optional context providing function scope lookup
- * @returns true if the when condition references other fields
+ * @internal
  */
-declare function hasCrossFieldWhenCondition(config: ValidatorConfig, context?: CrossFieldDetectionContext): boolean;
+type ImmediateDerivationTrigger = {
+    trigger?: 'onChange';
+    debounceMs?: never;
+};
+type DebouncedDerivationTrigger = {
+    trigger: 'debounced';
+    debounceMs?: number;
+};
 /**
- * Detects if a StateLogicConfig has a cross-field condition.
+ * Base for HTTP derivations. `source: 'http'` is required.
+ * TypeScript enforces `dependsOn` and `responseExpression` at the type level.
  *
- * @param config The state logic configuration to check
- * @param context Optional context providing function scope lookup
- * @returns true if the logic condition references other fields
+ * @internal
  */
-declare function isCrossFieldStateLogic(config: StateLogicConfig, context?: CrossFieldDetectionContext): boolean;
+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;
+}
 /**
- * Detects if a SchemaApplicationConfig has a cross-field condition.
+ * Shared fields for both branches of {@link AsyncFunctionDerivationBase}.
  *
- * @param config The schema application configuration to check
- * @param context Optional context providing function scope lookup
- * @returns true if the schema condition references other fields
+ * @internal
  */
-declare function isCrossFieldSchema(config: SchemaApplicationConfig, context?: CrossFieldDetectionContext): boolean;
-
-/**
- * Creates a lazy FieldStateInfo that only reads state properties when accessed.
+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).
  *
- * @param fieldSource - A FieldTree or direct FieldState instance
- * @param reactive - If true, reads signals reactively (creates dependencies).
- *                   If false, reads signals with `untracked()` (no dependencies).
- * @returns A FieldStateInfo proxy with lazy property access, or undefined if the source is invalid
  * @internal
  */
-declare function readFieldStateInfo(fieldSource: FieldTree<unknown> | ReadonlyFieldState<unknown> | undefined, reactive: boolean): FieldStateInfo | undefined;
+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;
+});
 /**
- * Creates a Proxy-based FormFieldStateMap for accessing any field's state by key.
+ * Base for expression derivations.
  *
- * @param rootForm - The root FieldTree of the form
- * @param reactive - If true, reads signals reactively (creates dependencies).
- *                   If false, reads signals with `untracked()` (no dependencies).
- * @returns A FormFieldStateMap proxy
  * @internal
  */
-declare function createFormFieldStateMap(rootForm: FieldTree<unknown>, reactive: boolean): FormFieldStateMap;
-
-/** DI-scoped cache for async condition logic functions. */
-declare class AsyncConditionFunctionCacheService {
-    /** Cache for async condition logic functions, keyed by serialized condition. */
-    readonly asyncConditionFunctionCache: Map<string, LogicFn<unknown, boolean>>;
+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;
 }
-
-/** Creates a logic function for an async condition. */
-declare function createAsyncConditionLogicFunction<TValue>(condition: AsyncCondition): LogicFn<TValue, boolean>;
-
 /**
- * Evaluate conditional expression
- * Uses secure AST-based parsing for JavaScript expressions
+ * Base for value derivations.
+ *
+ * @internal
  */
-declare function evaluateCondition(expression: ConditionalExpression, context: EvaluationContext): boolean;
-
+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;
+}
 /**
- * Trigger value carried through the debounced reactive pipeline.
+ * Shared fields for both branches of {@link FunctionDerivationBase}.
  *
  * @internal
  */
-interface Trigger<TPayload> {
-    key: string;
-    payload: TPayload;
+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;
 }
 /**
- * Configuration passed to {@link createDebouncedResourceLogicFn}.
+ * Base for custom sync function derivations. `functionName` and `fn` are
+ * mutually exclusive (XOR).
  *
  * @internal
  */
-interface DebouncedResourceLogicFnConfig<TValue, TPayload, TResult> {
-    /** Default value returned by the resource while loading / pending. */
-    pendingValue: TResult;
-    /** Debounce window (ms) applied to the trigger signal before the resource sees it. */
-    debounceMs: number;
-    injector: Injector;
-    /**
-     * Builds the per-emission inner observable. Called every time the debounced
-     * trigger key changes; the resource swaps to the new stream automatically.
-     */
-    buildStream: (payload: TPayload) => Observable<TResult>;
-    /**
-     * Called per LogicFn invocation. Returns one of:
-     *   - `{ kind: 'trigger', key, payload }` — set the trigger to this and
-     *     return the (potentially still-loading) resource value.
-     *   - `{ kind: 'returnEarly', value }` — bypass the resource and return
-     *     this value directly (used by HTTP for response-cache hits — the
-     *     cached value is authoritative and overrides any sticky resource value).
-     *   - `{ kind: 'holdPrevious' }` — bypass the resource update but return
-     *     the resource's current sticky value (its last resolved value via
-     *     `withPreviousValue`, or `pendingValue` if it never resolved). Used
-     *     by HTTP when the request template is temporarily unresolvable so
-     *     the UI doesn't flicker back to `pendingValue`.
-     */
-    resolve: (ctx: FieldContext<TValue>) => {
-        kind: 'trigger';
-        key: string;
-        payload: TPayload;
-    } | {
-        kind: 'returnEarly';
-        value: TResult;
-    } | {
-        kind: 'holdPrevious';
-    };
-}
+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;
+});
 /**
- * Shared scaffolding for both async-function and HTTP condition LogicFns.
+ * HTTP derivation that evaluates immediately on change (default).
  *
  * @internal
  */
-declare function createDebouncedResourceLogicFn<TValue, TPayload, TResult>(config: DebouncedResourceLogicFnConfig<TValue, TPayload, TResult>): LogicFn<TValue, TResult>;
-
-/** DI-scoped cache for HTTP condition logic functions. */
-declare class HttpConditionFunctionCacheService {
-    /** Cache for HTTP condition logic functions, keyed by serialized condition. */
-    readonly httpConditionFunctionCache: Map<string, LogicFn<unknown, boolean>>;
-}
-
-/** Creates a logic function for an HTTP condition. */
-declare function createHttpConditionLogicFunction<TValue>(condition: HttpCondition): LogicFn<TValue, boolean>;
-
+type OnChangeHttpDerivationLogicConfig = HttpDerivationBase & ImmediateDerivationTrigger;
 /**
- * Create a logic function from a conditional expression.
+ * HTTP derivation that evaluates after a debounce period.
  *
- * @param expression The conditional expression to evaluate
- * @returns A LogicFn that evaluates the condition in the context of a field
+ * @internal
  */
-declare function createLogicFunction<TValue>(expression: ConditionalExpression): LogicFn<TValue, boolean>;
+type DebouncedHttpDerivationLogicConfig = HttpDerivationBase & DebouncedDerivationTrigger;
 /**
- * Create a debounced logic function from a conditional expression.
+ * Async function derivation that evaluates immediately on change (default).
  *
- * @param expression The conditional expression to evaluate
- * @param debounceMs The debounce duration in milliseconds
- * @returns A LogicFn that evaluates the condition with debouncing
+ * @internal
  */
-declare function createDebouncedLogicFunction<TValue>(expression: ConditionalExpression, debounceMs: number): LogicFn<TValue, boolean>;
-
+type OnChangeAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & ImmediateDerivationTrigger;
 /**
- * Compares two values using the specified comparison operator.
+ * Async function derivation that evaluates after a debounce period.
  *
- * @param actual - The value to compare
- * @param expected - The value to compare against
- * @param operator - Comparison operator to use
- * @returns True if the comparison succeeds, false otherwise
+ * @internal
  */
-declare function compareValues(actual: unknown, expected: unknown, operator: string): boolean;
+type DebouncedAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & DebouncedDerivationTrigger;
 /**
- * Retrieves a nested value from an object using dot notation path.
+ * Expression derivation that evaluates immediately on change (default).
  *
- * @param obj - The object to traverse
- * @param path - Dot-separated path to the desired property
- * @returns The value at the specified path, or undefined if not found
+ * @internal
  */
-declare function getNestedValue(obj: unknown, path: string): unknown;
+type OnChangeExpressionDerivationLogicConfig = ExpressionDerivationBase & ImmediateDerivationTrigger;
 /**
- * Checks whether a nested property exists in an object using dot notation path.
+ * Expression derivation that evaluates after a debounce period.
  *
- * @param obj - The object to check
- * @param path - Dot-separated path to the property
- * @returns True if the property exists (even if its value is undefined)
+ * @internal
  */
-declare function hasNestedProperty(obj: unknown, path: string): boolean;
-
-/** Per-field debounced signal pair. */
-interface DebouncedSignalPair {
-    immediateValue: WritableSignal<boolean>;
-    debouncedValue: Signal<boolean | undefined>;
-}
-/** DI-scoped cache for logic functions and debounced signals. */
-declare class LogicFunctionCacheService {
-    /** Cache for memoized logic functions, keyed by serialized expression. */
-    readonly logicFunctionCache: Map<string, LogicFn<unknown, boolean>>;
-    /** Cache for debounced logic functions, keyed by serialized expression + debounceMs. */
-    readonly debouncedLogicFunctionCache: Map<string, LogicFn<unknown, boolean>>;
-    /** Per-field signal store for debounced logic, keyed by field path. */
-    readonly debouncedSignalStore: Map<string, DebouncedSignalPair>;
-}
-
-/** Base error class for all Dynamic Forms errors. */
-declare class DynamicFormError extends Error {
-    private static readonly PREFIX;
-    constructor(message: string);
+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';
+/** Configuration for derivation debug logging. */
+interface DerivationLogConfig {
+    /** Log level for derivation debugging. Defaults to 'none'. */
+    level: DerivationLogLevel;
 }
+/**
+ * Creates the default derivation log configuration.
+ *
+ * @returns Default DerivationLogConfig
+ */
+declare function createDefaultDerivationLogConfig(): DerivationLogConfig;
+/**
+ * Checks if logging should occur at the specified level.
+ *
+ * @param config - Current log configuration
+ * @param minLevel - Minimum level required for logging
+ * @returns True if logging should occur
+ */
+declare function shouldLog(config: DerivationLogConfig, minLevel: 'summary' | 'verbose'): boolean;
+/**
+ * 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;
+/**
+ * Type guard to check if a logic config is a StateLogicConfig.
+ *
+ * @param config - The logic config to check
+ * @returns true if the config is for field state logic
+ */
+declare function isStateLogicConfig(config: LogicConfig): config is StateLogicConfig;
+/**
+ * Type guard to check if a logic config is a DerivationLogicConfig.
+ *
+ * @param config - The logic config to check
+ * @returns true if the config is for value derivation
+ */
+declare function isDerivationLogicConfig(config: LogicConfig): config is DerivationLogicConfig;
+/**
+ * Type guard to check if a derivation config targets a property rather than the field value.
+ *
+ * @param config - The derivation logic config to check
+ * @returns true if the config has a targetProperty (property derivation)
+ */
+declare function hasTargetProperty(config: DerivationLogicConfig): config is DerivationLogicConfig & {
+    targetProperty: string;
+};
 
-/** Token types for expression parsing */
-declare enum TokenType {
-    NUMBER = "NUMBER",
-    STRING = "STRING",
-    TRUE = "TRUE",
-    FALSE = "FALSE",
-    NULL = "NULL",
-    UNDEFINED = "UNDEFINED",
-    IDENTIFIER = "IDENTIFIER",
-    PLUS = "PLUS",
-    MINUS = "MINUS",
-    MULTIPLY = "MULTIPLY",
-    DIVIDE = "DIVIDE",
-    MODULO = "MODULO",
-    EQUAL = "EQUAL",
-    NOT_EQUAL = "NOT_EQUAL",
-    GREATER = "GREATER",
-    LESS = "LESS",
-    GREATER_EQUAL = "GREATER_EQUAL",
-    LESS_EQUAL = "LESS_EQUAL",
-    AND = "AND",
-    OR = "OR",
-    NOT = "NOT",
-    DOT = "DOT",
-    COMMA = "COMMA",
-    COLON = "COLON",
-    LPAREN = "LPAREN",
-    RPAREN = "RPAREN",
-    LBRACKET = "LBRACKET",
-    RBRACKET = "RBRACKET",
-    LBRACE = "LBRACE",
-    RBRACE = "RBRACE",
-    ARROW = "ARROW",
-    QUESTION = "QUESTION",
-    OPTIONAL_DOT = "OPTIONAL_DOT",
-    EOF = "EOF"
-}
-/** Token with type, value, and position */
-interface Token {
-    type: TokenType;
-    value: string;
-    position: number;
-}
-/** AST Node types */
-type ASTNode = LiteralNode | IdentifierNode | MemberAccessNode | ComputedMemberAccessNode | BinaryOpNode | UnaryOpNode | CallExpressionNode | ConditionalNode | ArrayLiteralNode | ObjectLiteralNode | ArrowFunctionNode;
-interface LiteralNode {
-    type: 'Literal';
-    value: string | number | boolean | null | undefined;
+/** 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;
 }
-interface IdentifierNode {
-    type: 'Identifier';
+/** Reusable schema definition that can be referenced by name */
+interface SchemaDefinition {
+    /** Unique schema identifier */
     name: string;
-}
-interface MemberAccessNode {
-    type: 'MemberAccess';
-    object: ASTNode;
-    property: string;
-    /** True when this access used `?.` (optional chaining). */
-    optional?: boolean;
-}
-interface ComputedMemberAccessNode {
-    type: 'ComputedMemberAccess';
-    object: ASTNode;
-    /** Expression evaluated at runtime to produce the property key. */
-    property: ASTNode;
-    /** True when this access used `?.[ ... ]` (optional chaining). */
-    optional?: boolean;
-}
-interface ConditionalNode {
-    type: 'Conditional';
-    test: ASTNode;
-    consequent: ASTNode;
-    alternate: ASTNode;
-}
-interface BinaryOpNode {
-    type: 'BinaryOp';
-    operator: string;
-    left: ASTNode;
-    right: ASTNode;
-}
-interface UnaryOpNode {
-    type: 'UnaryOp';
-    operator: string;
-    operand: ASTNode;
-}
-interface CallExpressionNode {
-    type: 'CallExpression';
-    callee: ASTNode;
-    arguments: ASTNode[];
-    /** True when this call used `?.( ... )` (optional chaining). */
-    optional?: boolean;
-}
-interface ArrayLiteralNode {
-    type: 'ArrayLiteral';
-    elements: ASTNode[];
-}
-interface ObjectLiteralNode {
-    type: 'ObjectLiteral';
-    properties: Array<{
-        key: string;
-        value: ASTNode;
-    }>;
-}
-interface ArrowFunctionNode {
-    type: 'ArrowFunction';
-    params: string[];
-    body: ASTNode;
-}
-/** Parser error with position information */
-declare class ExpressionParserError extends DynamicFormError {
-    position: number;
-    expression: string;
-    constructor(message: string, position: number, expression: 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[];
 }
 
-/** Evaluation context for safe expression evaluation */
-interface EvaluationScope {
-    [key: string]: unknown;
-}
-/** Safely evaluates an AST node with a given context */
-declare class Evaluator {
-    private readonly scope;
-    private readonly expression;
-    constructor(scope: EvaluationScope, expression: string);
-    /** Evaluate an AST node */
-    evaluate(node: ASTNode): unknown;
-    private evaluateIdentifier;
-    private evaluateMemberAccess;
-    private evaluateComputedMemberAccess;
-    private evaluateBinaryOp;
-    private evaluateUnaryOp;
-    private evaluateCallExpression;
-    private evaluateArrayLiteral;
-    private evaluateObjectLiteral;
-    private evaluateArrowFunction;
-    private isMethodSafe;
+/**
+ * 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;
 }
 
-/** Secure expression parser that uses AST-based evaluation */
-declare class ExpressionParser {
+/**
+ * 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> {
     /**
-     * Parse an expression string into an AST
-     * Results are cached for performance using LRU eviction
+     * Action called when the form is submitted.
+     *
+     * @param form - The form's FieldTree instance
+     * @returns Promise or Observable - for errors, return TreeValidationResult
      */
-    static parse(expression: string): ASTNode;
-    /** Evaluate an expression with a given scope */
-    static evaluate(expression: string, scope: EvaluationScope): unknown;
-    /** Clear the AST cache */
-    static clearCache(): void;
-    /** Get cache statistics */
-    static getCacheStats(): {
-        size: number;
-        maxSize: number;
-    };
+    action: (form: FieldTree<TValue>) => SubmissionActionResult;
 }
 
 /**
- * Parses tokens into an Abstract Syntax Tree (AST)
- * Uses recursive descent parsing with operator precedence
- */
-declare class Parser {
-    private tokens;
-    private current;
-    private readonly expression;
-    constructor(expression: string);
-    /** Parse the expression into an AST */
-    parse(): ASTNode;
-    private parseExpression;
+ * 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<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>;
     /**
-     * Ternary `test ? consequent : alternate` — right-associative, sits between
-     * the arrow-function check and logical-or in precedence.
+     * Global form configuration options.
+     *
+     * @value {}
      */
-    private parseConditional;
+    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 {
     /**
-     * Attempts to parse an arrow function. Returns null and leaves position
-     * unchanged if the next tokens don't form an arrow function head.
+     * Disable the entire form.
+     *
+     * @value false
      */
-    private tryParseArrowFunction;
-    private checkAt;
-    private parseLogicalOr;
-    private parseLogicalAnd;
-    private parseEquality;
-    private parseComparison;
-    private parseAddition;
-    private parseMultiplication;
-    private parseUnary;
-    private parsePostfix;
-    private parsePrimary;
-    private parseArgumentList;
-    private parseArrayElements;
-    private parseObjectProperties;
-    private match;
-    private check;
-    private advance;
-    private isAtEnd;
-    private peek;
-    private previous;
-    private consume;
+    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;
 }
-
-/** Tokenizes an expression string into tokens */
-declare class Tokenizer {
-    private position;
-    private readonly expression;
-    constructor(expression: string);
-    /** Tokenize the entire expression */
-    tokenize(): Token[];
-    private skipWhitespace;
-    private nextToken;
-    private readString;
-    private readNumber;
-    private readIdentifierOrKeyword;
-    private getKeywordType;
-    private readOperatorOrPunctuation;
+/** 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;
 }
 
-/** Represents a FieldTree node for dynamic bracket-access navigation. */
-type FieldTreeRecord = Record<string, FieldTree<unknown> | undefined>;
-/**
- * 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[]>;
+/** 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;
 }
 /**
- * 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).
+ * 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.
  */
-declare function writeToFieldValue<T>(value: Signal<T>, next: T, logger?: {
-    warn: (msg: string) => void;
-}): boolean;
+type NonFieldLogicType = 'hidden' | 'disabled';
 /**
- * DI-scoped cache for `ReadonlyFieldTree` views, keyed on the source FieldTree
- * identity. A fresh WeakMap per root injector keeps renders isolated under SSR —
- * Angular creates a new root injector per request, so there's no shared state
- * between server renders (same pattern as `COMPONENT_CACHE`).
- *
- * @internal
+ * Logic config restricted to types valid for non-form-bound elements.
+ * This is a subset of LogicConfig that only includes hidden and disabled types.
  */
-declare const READONLY_FIELD_TREE_CACHE: InjectionToken<WeakMap<FieldTree<unknown>, ReadonlyFieldTree<unknown>>>;
-/**
- * Cached variant of {@link toReadonlyFieldTree}. Each FieldTree instance is a
- * stable reference for the lifetime of its form, so one `ReadonlyFieldTree`
- * view per tree is enough. Callers on hot paths (`pushInputs` on every mapper
- * emission) avoid re-allocating the nine-property view object.
+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.
  *
- * @internal
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
  */
-declare function toReadonlyFieldTreeCached<TValue>(cache: WeakMap<FieldTree<unknown>, ReadonlyFieldTree<unknown>>, field: FieldTree<TValue>): ReadonlyFieldTree<TValue>;
-
-/** TTL cache for HTTP condition responses with max entries eviction. */
-declare class HttpConditionCache {
-    private readonly cache;
-    private readonly maxEntries;
-    constructor(maxEntries?: number);
-    get(key: string): boolean | undefined;
-    set(key: string, value: boolean, ttlMs: number): void;
-    clear(): void;
-}
-/** @internal */
-declare const HTTP_CONDITION_CACHE: InjectionToken<HttpConditionCache>;
-
+declare function resolveSubmitButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
 /**
- * Resolves an `HttpRequestConfig` into an `HttpResourceRequest` by evaluating
- * expression-based query params and (optionally) body values.
+ * 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 resolveHttpRequest(config: HttpRequestConfig, context: EvaluationContext): HttpResourceRequest | null;
-
-/** Evaluates an HTTP response against a `HttpValidationResponseMapping` to produce a validation result. */
-declare function evaluateHttpValidationResponse(response: unknown, mapping: HttpValidationResponseMapping, logger: Logger): ValidationError$1 | null;
-
-type DynamicText = string | Observable<string> | Signal<string>;
+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>;
 
-/** Generic reactive value — a static value, an Angular Signal, or an RxJS Observable. */
-type DynamicValue<T> = T | Signal<T> | Observable<T>;
+/** 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[];
+}
 
-/** Universal addon slot names supported by every adapter. */
-type CommonAddonSlot = 'prefix' | 'suffix';
-/** Module-augmentable registry of adapter-specific addon slot names. */
-interface DynamicFormAddonSlotRegistry {
+/** Configuration for the built-in 'css' wrapper type. */
+interface CssWrapper {
+    readonly type: 'css';
+    /** CSS classes to apply to the wrapper */
+    readonly cssClasses?: DynamicText;
 }
-/**
- * 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>;
+/** Configuration for the built-in 'row' wrapper type. */
+interface RowWrapper {
+    readonly type: 'row';
 }
-/** Module-augmentable registry of addon kinds. */
-interface DynamicFormAddonRegistry {
-    text: TextAddon;
-    template: TemplateAddon;
-    component: ComponentAddon;
+
+/** Container fields registry - augment this interface to add custom container fields */
+interface FieldRegistryContainers {
+    page: PageField;
+    row: RowField;
+    group: GroupField;
+    array: ArrayField | SimplifiedArrayField;
+    container: ContainerField;
 }
-/** 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;
+/** Leaf fields registry - augment this interface to add custom leaf fields */
+interface FieldRegistryLeaves {
+    text: TextField;
+    hidden: HiddenField;
 }
-/** Renders a named `<ng-template>` projected into the host `<df-dynamic-form>`. */
-interface TemplateAddon extends BaseAddon {
-    readonly kind: 'template';
-    readonly templateKey: string;
+/** Wrapper type registry for module augmentation. */
+interface FieldRegistryWrappers {
+    css: CssWrapper;
+    row: RowWrapper;
 }
 /**
- * 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' })`).
+ * Global interface for dynamic form field definitions with categorization
+ * This interface combines containers and leaves from their respective registries
  */
-interface ComponentAddon extends BaseAddon {
-    readonly kind: 'component';
-    readonly component: () => Promise<Type<unknown> | {
-        default: Type<unknown>;
-    }>;
-    readonly inputs?: Record<string, unknown>;
+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;
 }
-
-type WithInputSignals<T> = {
-    readonly [K in keyof T]-?: Signal<T[K]>;
-};
-
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+/** 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>[];
 
 /** Resolves a wrapper type name to its registered config interface. */
 type WrapperConfig<TWrappers extends RegisteredWrapperTypes = RegisteredWrapperTypes> = TWrappers extends keyof FieldRegistryWrappers ? FieldRegistryWrappers[TWrappers] : {
@@ -1490,906 +1862,853 @@ declare const WRAPPER_COMPONENT_CACHE: InjectionToken<Map<string, Type<unknown>>
  */
 declare const WRAPPER_AUTO_ASSOCIATIONS: InjectionToken<WrapperAutoAssociations>;
 
-/** 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;
+/**
+ * Minimal JSON Schema fragment used by the MCP server to surface an addon
+ * type'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 AddonTypeSchema {
+    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, AddonTypeSchema>>;
+    readonly required?: ReadonlyArray<string>;
+    readonly additionalProperties?: boolean | AddonTypeSchema;
+    readonly items?: AddonTypeSchema | ReadonlyArray<AddonTypeSchema>;
+    readonly oneOf?: ReadonlyArray<AddonTypeSchema>;
+    readonly anyOf?: ReadonlyArray<AddonTypeSchema>;
+    readonly allOf?: ReadonlyArray<AddonTypeSchema>;
+    readonly not?: AddonTypeSchema;
+    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;
 }
-
 /**
- * Base interface for all dynamic form field definitions.
- *
- * @typeParam TProps - Field-specific properties interface
- * @typeParam TMeta - Native HTML attributes interface (extends FieldMeta)
+ * Optional shape validator a type 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.
  */
-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;
+type AddonShapeValidator<T extends BaseAddon = BaseAddon> = (addon: T, fieldKey: string) => void;
+/** Per-type registration metadata. */
+interface AddonTypeDefinition<T extends BaseAddon = BaseAddon> {
+    /** Discriminant matching `addon.type`. */
+    readonly type: string;
+    /** Lazy loader for the type'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?: AddonTypeSchema;
     /**
-     * Skip the form-level `defaultWrappers` layer while keeping auto-associations
-     * and any field-level `wrappers`.
+     * Whether the type survives `JSON.stringify` / `JSON.parse`. Types 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` — types are JSON-safe unless explicitly opted out.
      */
-    skipDefaultWrappers?: boolean;
-    /** Addons rendered inside this field's slots (typically `prefix` / `suffix`). */
-    addons?: ReadonlyArray<AnyAddon>;
+    readonly jsonSafe?: boolean;
 }
-type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
+/** 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 types. Omitted = any registered type. */
+    readonly allowedTypes?: readonly string[];
+}
+/** Global registry of addon types. */
+declare const ADDON_TYPE_REGISTRY: InjectionToken<Map<string, AddonTypeDefinition<BaseAddon<AddonSlot>>>>;
 /**
- * Type utility for extracting component input properties from field definitions.
+ * Cache for resolved addon-type components. Provided at form scope by
+ * `provideDynamicForm`.
  *
- * @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
+ * @internal
  */
-type FieldComponent<T extends FieldDef<unknown, FieldMeta>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
+declare const ADDON_TYPE_COMPONENT_CACHE: InjectionToken<Map<string, Type<unknown>>>;
 
 /**
- * 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).
+ * Multi-provider token used by `withCustomAddon(...)` features to contribute
+ * addon type definitions. `provideDynamicForm` aggregates all values into
+ * the form-scoped `ADDON_TYPE_REGISTRY` map.
+ *
+ * @internal
  */
-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;
-}
+declare const ADDON_TYPE_DEFINITIONS: InjectionToken<readonly AddonTypeDefinition<_ng_forge_dynamic_forms_internal.BaseAddon<_ng_forge_dynamic_forms_internal.AddonSlot>>[]>;
 
+/** Represents a FieldTree node for dynamic bracket-access navigation. */
+type FieldTreeRecord = Record<string, FieldTree<unknown> | undefined>;
 /**
- * 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.
+ * Type representing a FieldTree for an array.
+ * Extends FieldTree to add numeric indexing for accessing item FieldTrees.
  */
-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 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[]>;
 }
-/** Type guard for RowField with proper type narrowing */
-declare function isRowField(field: FieldDef<any>): field is RowField;
-type RowComponent = FieldComponent<RowField<RowAllowedChildren[]>>;
-
 /**
- * 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
+ * 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.
  */
-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;
-type GroupComponent<T extends GroupAllowedChildren[]> = FieldComponent<GroupField<T>>;
+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;
+/**
+ * DI-scoped cache for `ReadonlyFieldTree` views, keyed on the source FieldTree
+ * identity. A fresh WeakMap per root injector keeps renders isolated under SSR —
+ * Angular creates a new root injector per request, so there's no shared state
+ * between server renders (same pattern as `COMPONENT_CACHE`).
+ *
+ * @internal
+ */
+declare const READONLY_FIELD_TREE_CACHE: InjectionToken<WeakMap<FieldTree<unknown>, ReadonlyFieldTree<unknown>>>;
+/**
+ * Cached variant of {@link toReadonlyFieldTree}. Each FieldTree instance is a
+ * stable reference for the lifetime of its form, so one `ReadonlyFieldTree`
+ * view per tree is enough. Callers on hot paths (`pushInputs` on every mapper
+ * emission) avoid re-allocating the nine-property view object.
+ *
+ * @internal
+ */
+declare function toReadonlyFieldTreeCached<TValue>(cache: WeakMap<FieldTree<unknown>, ReadonlyFieldTree<unknown>>, field: FieldTree<TValue>): ReadonlyFieldTree<TValue>;
 
-/** 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;
+/** 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;
     /**
-     * Logic configurations for conditional container visibility.
-     * Only 'hidden' type logic is supported for containers.
+     * 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 logic?: ContainerLogicConfig[];
+    readonly setValue?: (next: unknown) => void;
+    readonly [key: string]: unknown;
 }
-/** Type guard for ContainerField with proper type narrowing. */
-declare function isContainerTypedField(field: FieldDef<any>): field is ContainerField;
-type ContainerComponent = FieldComponent<ContainerField<ContainerAllowedChildren[]>>;
 
 /**
- * Type constraints for field nesting rules
- * These ensure that container fields can only contain valid child field types
+ * Dispatcher component that renders an addon by looking up its `type` in
+ * `ADDON_TYPE_REGISTRY` and instantiating the registered component.
  */
+declare class DfAddonSlot {
+    private readonly registry;
+    private readonly logger;
+    private readonly hostInjector;
+    readonly addon: i0.InputSignal<AnyAddon>;
+    /**
+     * Optional read-only view of the host field's mapped inputs — same shape
+     * wrappers receive (`field?: ReadonlyFieldTree`, `key`, `props`, etc.).
+     * Forwarded to type components so they can read field state without
+     * re-injecting `FIELD_SIGNAL_CONTEXT` and rebuilding context themselves.
+     */
+    readonly fieldInputs: i0.InputSignal<WrapperFieldInputs | undefined>;
+    /**
+     * Pre-resolved `hidden` signal supplied by the host field. When provided,
+     * the dispatcher reads this instead of re-resolving `addon.hidden` —
+     * lets the host (e.g., `prime-input`) share a single subscription per
+     * Observable-typed `hidden` between its own visibility filter and the
+     * slot's `[style.display]` binding.
+     */
+    readonly hidden: i0.InputSignal<Signal<boolean> | undefined>;
+    /** `slot` HTML attribute forwarded to host — needed for Ionic shadow projection. */
+    protected readonly slotAttr: Signal<_ng_forge_dynamic_forms_internal.AddonSlot>;
+    protected readonly className: Signal<string | null>;
+    /**
+     * Locally-resolved `hidden` signal — always reflects `addon.hidden`
+     * regardless of whether the host supplied a pre-resolved signal.
+     * Populated via `explicitEffect` so `resolveDynamicValue` (which may call
+     * `toSignal` for Observable-typed values) does NOT run inside a reactive
+     * context (NG0602). The WeakMap caches per `hidden`-value identity, so
+     * swapping `addon` inputs that share the same Observable reuses the
+     * subscription instead of leaking a fresh one per swap.
+     */
+    private readonly _hiddenByValue;
+    private readonly _resolvedHidden;
+    /**
+     * `hidden` resolved from `DynamicValue<boolean>` to a flat `Signal<boolean>`.
+     * Prefers the host-supplied signal when present (avoids duplicate `toSignal`
+     * subscriptions for Observable-typed `hidden`); falls back to the locally-
+     * resolved signal, which is always populated by the addon-tracking effect.
+     */
+    protected readonly isHidden: Signal<boolean>;
+    /**
+     * Latest async-loaded `{ type, component }` pair. Tagging the result with
+     * its type lets `resolvedComponent` filter stale loads structurally — no
+     * monotonic token needed. When `addon.type` changes mid-load, the prior
+     * load still completes and writes here, but the computed ignores it
+     * because the recorded type no longer matches the current one.
+     */
+    private readonly asyncLoaded;
+    /**
+     * Resolved type component — composed declaratively from two sources of
+     * truth: the registry's synchronous cache (warm hits, e.g., a second
+     * `<df-addon-slot>` for an already-loaded type) and the type-tagged async
+     * loader result. Reading `addon().type` first makes the computed react to
+     * addon swaps and naturally invalidate stale async-load results.
+     */
+    protected readonly resolvedComponent: Signal<Type<unknown> | undefined>;
+    /** Inputs passed to the type component — addon plus the wrapper-style host bag. */
+    protected readonly typeInputs: Signal<{
+        addon: AnyAddon;
+        fieldInputs: WrapperFieldInputs | undefined;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAddonSlot, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfAddonSlot, "df-addon-slot", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
- * Fields that are allowed as children of Page fields
- * Pages can contain: rows, groups, arrays, and leaf fields (but NOT other pages)
+ * Public shape returned by {@link injectAddonTypeRegistry}. Pinned explicitly
+ * so the API extractor doesn't churn between versions when the inner factory
+ * gets refactored.
  */
-type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
+interface AddonTypeRegistryRef {
+    getType(type: string): AddonTypeDefinition | undefined;
+    hasType(type: string): boolean;
+    getTypeNames(): string[];
+    loadTypeComponent(type: string): Promise<Type<unknown>>;
+    getLoadedTypeComponent(type: string): Type<unknown> | undefined;
+    readonly raw: ReadonlyMap<string, AddonTypeDefinition>;
+}
+/** Injection function for accessing the addon type registry. */
+declare function injectAddonTypeRegistry(): AddonTypeRegistryRef;
+
+/** One entry per field type that declares addon support. */
+interface FieldAddonSupportEntry {
+    readonly name: string;
+    readonly slots: FieldAddonSupport['slots'];
+    readonly allowedTypes: FieldAddonSupport['allowedTypes'];
+}
 /**
- * Fields that are allowed as children of Group fields
- * Groups can contain: rows, arrays, and leaf fields (but NOT pages or other groups)
+ * Walk `FIELD_REGISTRY` and return every field type that opted into addons
+ * (i.e., declared `addons` on its `FieldTypeDefinition`).
+ *
+ * @Component({ ... })
+ * class FormBuilder {
+ *   protected readonly addonable = injectFieldsSupportingAddons();
+ *
+ *   constructor() {
+ *     // -> [{ name: 'prime-input', slots: ['prefix', 'suffix'], allowedTypes: [...] }, ...]
+ *   }
+ * }
+ * ```
  */
-type GroupAllowedChildren = LeafFieldTypes | RowField | ArrayField | SimplifiedArrayField | ContainerField;
+declare function injectFieldsSupportingAddons(): FieldAddonSupportEntry[];
+
 /**
- * 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
+ * Fields every addon-action context carries, regardless of whether the
+ * addon is bound to a host field or rendered orphaned.
  */
-type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField | ContainerField;
+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;
+}
 /**
- * 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.
+ * 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.
  */
-type ContainerAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
+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;
+}
 /**
- * Row is a synthetic field type that resolves to a Container at runtime, so
- * it accepts the same children as a Container.
+ * 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`.
  */
-type RowAllowedChildren = ContainerAllowedChildren;
-
+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 {
+}
 /**
- * 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, ... }`.
+ * Union of every preset name an addon may reference — universal presets
+ * plus any contributed via {@link DynamicFormAddonActionPresetRegistry}.
  */
-type ArrayItemTemplate = readonly ArrayAllowedChildren[];
+type AddonActionPreset = CommonAddonActionPreset | keyof DynamicFormAddonActionPresetRegistry | (string & {});
+/** Module-augmentable registry of user-defined named action handlers. */
+interface DynamicFormActionRegistry {
+}
 /**
- * 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
+ * Typed string handle to a registered action handler. The empty registry
+ * resolves to `never`; augmenting `DynamicFormActionRegistry` populates the
+ * union and unlocks autocomplete.
  */
-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[];
+type RegisteredActionRef = keyof DynamicFormActionRegistry;
+
+/**
+ * Optional collaborators a preset may need beyond the base context. Passed
+ * by the button kind component which has access to its own DI scope.
+ */
+interface PresetCollaborators {
+    /** Per-field input-type override signal — populated only inside an input field. */
+    readonly typeOverride?: WritableSignal<string | undefined>;
+    /** Writer that pushes a value into the host field's tree. */
+    readonly fieldValueSetter?: (next: unknown) => void;
     /**
-     * Minimum number of items required in the array.
-     * Validation fails if the array has fewer items than this value.
+     * Read the host field's configured default value (from the form's
+     * `defaultValues` map keyed by `field.key`). Used by the `'reset'`
+     * preset; absent when the addon is rendered outside an active field
+     * context, in which case `'reset'` falls back to clearing.
      */
-    readonly minLength?: number;
+    readonly fieldDefaultValueGetter?: () => unknown;
     /**
-     * Maximum number of items allowed in the array.
-     * Validation fails if the array has more items than this value.
+     * Baseline configured input type (from `props().type`), read at preset-run
+     * time. Used by `toggle-password-visibility` to refuse to corrupt
+     * `'email'`/`'number'`/etc. inputs into `'password'` when no override is
+     * yet set.
      */
-    readonly maxLength?: number;
+    readonly baselineType?: () => string | undefined;
+    /** Logger for warnings about presets that can't be fulfilled in this context. */
+    readonly logger: Logger;
 }
 /**
- * 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).
+ * Apply a built-in preset action against the addon's host field. Shared
+ * across all adapters — each adapter's `ADDON_PRESET_HANDLER` provider
+ * delegates here.
+ *
+ * @param adapterLabel Used in warnings — `'Material'` / `'Bootstrap'` / etc.
+ * @param fieldLabel   Used in warnings — `'mat-input'` / `'bs-input'` / etc.
  */
-declare function isArrayField(field: FieldDef<any>): field is ArrayField;
-type ArrayComponent<T extends ArrayItemTemplate[]> = FieldComponent<ArrayField<T>>;
-/** 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;
+declare function runPresetAction(preset: AddonActionPreset, ctx: AddonActionContext, collaborators: PresetCollaborators, adapterLabel: string, fieldLabel: string): Promise<void>;
+
+/** Context for cross-field detection, providing access to function scope information. */
+interface CrossFieldDetectionContext {
     /**
-     * Maximum number of items allowed in the array.
-     * Validation fails if the array has more items than this value.
+     * Lookup function to get the scope of a registered custom function.
+     *
+     * @param functionName The name of the custom function
+     * @returns The function's scope, or undefined if not registered
      */
-    readonly maxLength?: number;
-    /** Mutually exclusive with `template` — use `fields` for the full API instead */
-    readonly fields?: never;
+    getFunctionScope?: (functionName: string) => CustomFunctionScope | undefined;
 }
 /**
- * Type guard for SimplifiedArrayField.
- * Checks for `type: 'array'` with a `template` property (discriminant from full ArrayField).
+ * Detects if a ConditionalExpression references other fields (cross-field).
+ *
+ * @param expr The conditional expression to analyze
+ * @param context Optional context providing function scope lookup
+ * @returns true if the expression references other fields
  */
-declare function isSimplifiedArrayField(field: FieldDef<any>): field is SimplifiedArrayField;
-
+declare function isCrossFieldExpression(expr: ConditionalExpression | boolean | FormStateCondition | undefined, context?: CrossFieldDetectionContext): boolean;
 /**
- * Scalar types supported by hidden fields.
- * These are the primitive value types that can be stored.
+ * Extracts field dependencies from a ConditionalExpression.
+ *
+ * @param expr The conditional expression to analyze
+ * @returns Array of field keys that this expression depends on
  */
-type HiddenScalar = string | number | boolean;
+declare function extractExpressionDependencies(expr: ConditionalExpression | boolean | undefined): string[];
 /**
- * All value types supported by hidden fields.
- * Supports both scalar values and arrays of scalars for storing
- * multiple IDs or similar data.
+ * Extracts field names from a JavaScript expression string.
+ * Handles both dot notation (formValue.field) and bracket notation (formValue['field']).
  */
-type HiddenValue = HiddenScalar | HiddenScalar[];
+declare function extractStringDependencies(expression: string): string[];
 /**
- * Hidden field definition for storing values without rendering UI.
+ * Detects if a custom validator configuration references formValue (cross-field validation).
  *
- * @typeParam TValue - The type of value stored (must be HiddenValue compatible)
+ * @param config The custom validator configuration to check
+ * @returns true if the validator references formValue
  */
-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;
-}
+declare function isCrossFieldValidator(config: CustomValidatorConfig): boolean;
 /**
- * Type guard to check if a field is a hidden field.
+ * Detects if a built-in validator has a dynamic expression that references formValue.
  *
- * @param field - The field to check
- * @returns True if the field is a HiddenField
+ * @param config The validator configuration to check
+ * @returns true if the validator has a cross-field dynamic expression
  */
-declare function isHiddenField(field: FieldDef<unknown>): field is HiddenField;
-
+declare function isCrossFieldBuiltInValidator(config: ValidatorConfig): boolean;
+/** Checks if a validator uses Angular's resource API (validateHttp / validateAsync). */
+declare function isResourceBasedValidator(config: ValidatorConfig): boolean;
 /**
- * Page field interface for creating top-level page layouts
- * This is a special field type that contains other field definitions
- * The page itself doesn't have a value - it's a layout container like row
- * Pages can only be used at the top level and cannot be nested
- * This is a programmatic field type only - users cannot customize this field type
+ * Detects if a validator's `when` condition is cross-field.
+ *
+ * @param config The validator configuration to check
+ * @param context Optional context providing function scope lookup
+ * @returns true if the when condition references other fields
  */
-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;
+declare function hasCrossFieldWhenCondition(config: ValidatorConfig, context?: CrossFieldDetectionContext): boolean;
 /**
- * Validates that a page field doesn't contain nested page fields
+ * Detects if a StateLogicConfig has a cross-field condition.
  *
- * @param pageField The page field to validate
- * @returns true if valid (no nested pages), false otherwise
- */
-declare function validatePageNesting(pageField: PageField): 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[];
-}
-
-/** 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';
-}
-
-/** 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
+ * @param config The state logic configuration to check
+ * @param context Optional context providing function scope lookup
+ * @returns true if the logic condition references other fields
  */
-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'];
+declare function isCrossFieldStateLogic(config: StateLogicConfig, context?: CrossFieldDetectionContext): boolean;
 /**
- * Combined registry mapping type names to field definitions.
- * This flattens containers and leaves into a single mapping.
+ * Detects if a SchemaApplicationConfig has a cross-field condition.
+ *
+ * @param config The schema application configuration to check
+ * @param context Optional context providing function scope lookup
+ * @returns true if the schema condition references other fields
  */
-type FieldTypeMap = DynamicFormFieldRegistry['containers'] & DynamicFormFieldRegistry['leaves'];
+declare function isCrossFieldSchema(config: SchemaApplicationConfig, context?: CrossFieldDetectionContext): boolean;
+
 /**
- * Extract a specific field type from RegisteredFieldTypes based on the `type` discriminant.
- * This enables proper type narrowing when defining fields.
+ * Creates a lazy FieldStateInfo that only reads state properties when accessed.
+ *
+ * @param fieldSource - A FieldTree or direct FieldState instance
+ * @param reactive - If true, reads signals reactively (creates dependencies).
+ *                   If false, reads signals with `untracked()` (no dependencies).
+ * @returns A FieldStateInfo proxy with lazy property access, or undefined if the source is invalid
+ * @internal
  */
-type ExtractField<T extends AvailableFieldTypes> = T extends keyof FieldTypeMap ? FieldTypeMap[T] : never;
+declare function readFieldStateInfo(fieldSource: FieldTree<unknown> | ReadonlyFieldState<unknown> | undefined, reactive: boolean): FieldStateInfo | undefined;
 /**
- * Narrow a field definition based on its `type` property.
- * Use this to get proper type inference when working with field unions.
+ * Creates a Proxy-based FormFieldStateMap for accessing any field's state by key.
+ *
+ * @param rootForm - The root FieldTree of the form
+ * @param reactive - If true, reads signals reactively (creates dependencies).
+ *                   If false, reads signals with `untracked()` (no dependencies).
+ * @returns A FormFieldStateMap proxy
+ * @internal
  */
-type NarrowField<T> = T extends {
-    type: infer TType;
-} ? (TType extends AvailableFieldTypes ? ExtractField<TType> : T) : T;
+declare function createFormFieldStateMap(rootForm: FieldTree<unknown>, reactive: boolean): FormFieldStateMap;
+
+/** DI-scoped cache for async condition logic functions. */
+declare class AsyncConditionFunctionCacheService {
+    /** Cache for async condition logic functions, keyed by serialized condition. */
+    readonly asyncConditionFunctionCache: Map<string, LogicFn<unknown, boolean>>;
+}
+
+/** Creates a logic function for an async condition. */
+declare function createAsyncConditionLogicFunction<TValue>(condition: AsyncCondition): LogicFn<TValue, boolean>;
+
 /**
- * Narrow each field in an array based on its `type` property.
- * Use with `satisfies` to get proper type inference for field arrays.
+ * Evaluate conditional expression
+ * Uses secure AST-based parsing for JavaScript expressions
  */
-type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
+declare function evaluateCondition(expression: ConditionalExpression, context: EvaluationContext): boolean;
 
 /**
- * Helper type to convert union to intersection.
- * Uses `U extends U` to trigger distributive conditional type behavior.
+ * Trigger value carried through the debounced reactive pipeline.
+ *
+ * @internal
  */
-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];
+interface Trigger<TPayload> {
+    key: string;
+    payload: TPayload;
+}
 /**
- * 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`.
+ * Configuration passed to {@link createDebouncedResourceLogicFn}.
+ *
+ * @internal
  */
-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;
+interface DebouncedResourceLogicFnConfig<TValue, TPayload, TResult> {
+    /** Default value returned by the resource while loading / pending. */
+    pendingValue: TResult;
+    /** Debounce window (ms) applied to the trigger signal before the resource sees it. */
+    debounceMs: number;
+    injector: Injector;
+    /**
+     * Builds the per-emission inner observable. Called every time the debounced
+     * trigger key changes; the resource swaps to the new stream automatically.
+     */
+    buildStream: (payload: TPayload) => Observable<TResult>;
+    /**
+     * Called per LogicFn invocation. Returns one of:
+     *   - `{ kind: 'trigger', key, payload }` — set the trigger to this and
+     *     return the (potentially still-loading) resource value.
+     *   - `{ kind: 'returnEarly', value }` — bypass the resource and return
+     *     this value directly (used by HTTP for response-cache hits — the
+     *     cached value is authoritative and overrides any sticky resource value).
+     *   - `{ kind: 'holdPrevious' }` — bypass the resource update but return
+     *     the resource's current sticky value (its last resolved value via
+     *     `withPreviousValue`, or `pendingValue` if it never resolved). Used
+     *     by HTTP when the request template is temporarily unresolvable so
+     *     the UI doesn't flicker back to `pendingValue`.
+     */
+    resolve: (ctx: FieldContext<TValue>) => {
+        kind: 'trigger';
+        key: string;
+        payload: TPayload;
+    } | {
+        kind: 'returnEarly';
+        value: TResult;
+    } | {
+        kind: 'holdPrevious';
+    };
+}
 /**
- * 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`.
+ * Shared scaffolding for both async-function and HTTP condition LogicFns.
+ *
+ * @internal
  */
-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>;
+declare function createDebouncedResourceLogicFn<TValue, TPayload, TResult>(config: DebouncedResourceLogicFnConfig<TValue, TPayload, TResult>): LogicFn<TValue, TResult>;
+
+/** DI-scoped cache for HTTP condition logic functions. */
+declare class HttpConditionFunctionCacheService {
+    /** Cache for HTTP condition logic functions, keyed by serialized condition. */
+    readonly httpConditionFunctionCache: Map<string, LogicFn<unknown, boolean>>;
+}
+
+/** Creates a logic function for an HTTP condition. */
+declare function createHttpConditionLogicFunction<TValue>(condition: HttpCondition): LogicFn<TValue, boolean>;
+
 /**
- * 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`.
+ * Create a logic function from a conditional expression.
+ *
+ * @param expression The conditional expression to evaluate
+ * @returns A LogicFn that evaluates the condition in the context of a field
  */
-type InferValueType<T, V> = T extends {
-    nullable: true;
-} ? ResolveBaseValueType<T, V> | null : ResolveBaseValueType<T, V>;
+declare function createLogicFunction<TValue>(expression: ConditionalExpression): LogicFn<TValue, boolean>;
 /**
- * Make type optional if field is not required.
- * Hidden fields are never optional since they require a value property.
+ * Create a debounced logic function from a conditional expression.
+ *
+ * @param expression The conditional expression to evaluate
+ * @param debounceMs The debounce duration in milliseconds
+ * @returns A LogicFn that evaluates the condition with debouncing
  */
-type MaybeOptional<T, V> = T extends {
-    type: 'hidden';
-} ? V : T extends {
-    required: true;
-} ? V : V | undefined;
+declare function createDebouncedLogicFunction<TValue>(expression: ConditionalExpression, debounceMs: number): LogicFn<TValue, boolean>;
+
 /**
- * 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.
+ * Compares two values using the specified comparison operator.
+ *
+ * @param actual - The value to compare
+ * @param expected - The value to compare against
+ * @param operator - Comparison operator to use
+ * @returns True if the comparison succeeds, false otherwise
  */
-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>;
+declare function compareValues(actual: unknown, expected: unknown, operator: string): boolean;
 /**
- * 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
+ * Retrieves a nested value from an object using dot notation path.
+ *
+ * @param obj - The object to traverse
+ * @param path - Dot-separated path to the desired property
+ * @returns The value at the specified path, or undefined if not found
  */
-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;
+declare function getNestedValue(obj: unknown, path: string): unknown;
 /**
- * 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.
+ * Checks whether a nested property exists in an object using dot notation path.
+ *
+ * @param obj - The object to check
+ * @param path - Dot-separated path to the property
+ * @returns True if the property exists (even if its value is undefined)
  */
-type InferFormValue<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<ExtractFields<T> extends RegisteredFieldTypes[] ? ExtractFields<T> : [...ExtractFields<T>], 5> : never;
+declare function hasNestedProperty(obj: unknown, path: string): boolean;
+
+/** Per-field debounced signal pair. */
+interface DebouncedSignalPair {
+    immediateValue: WritableSignal<boolean>;
+    debouncedValue: Signal<boolean | undefined>;
+}
+/** DI-scoped cache for logic functions and debounced signals. */
+declare class LogicFunctionCacheService {
+    /** Cache for memoized logic functions, keyed by serialized expression. */
+    readonly logicFunctionCache: Map<string, LogicFn<unknown, boolean>>;
+    /** Cache for debounced logic functions, keyed by serialized expression + debounceMs. */
+    readonly debouncedLogicFunctionCache: Map<string, LogicFn<unknown, boolean>>;
+    /** Per-field signal store for debounced logic, keyed by field path. */
+    readonly debouncedSignalStore: Map<string, DebouncedSignalPair>;
+}
+
+/** Base error class for all Dynamic Forms errors. */
+declare class DynamicFormError extends Error {
+    private static readonly PREFIX;
+    constructor(message: string);
+}
+
+/** Token types for expression parsing */
+declare enum TokenType {
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    TRUE = "TRUE",
+    FALSE = "FALSE",
+    NULL = "NULL",
+    UNDEFINED = "UNDEFINED",
+    IDENTIFIER = "IDENTIFIER",
+    PLUS = "PLUS",
+    MINUS = "MINUS",
+    MULTIPLY = "MULTIPLY",
+    DIVIDE = "DIVIDE",
+    MODULO = "MODULO",
+    EQUAL = "EQUAL",
+    NOT_EQUAL = "NOT_EQUAL",
+    GREATER = "GREATER",
+    LESS = "LESS",
+    GREATER_EQUAL = "GREATER_EQUAL",
+    LESS_EQUAL = "LESS_EQUAL",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    DOT = "DOT",
+    COMMA = "COMMA",
+    COLON = "COLON",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    LBRACE = "LBRACE",
+    RBRACE = "RBRACE",
+    ARROW = "ARROW",
+    QUESTION = "QUESTION",
+    OPTIONAL_DOT = "OPTIONAL_DOT",
+    EOF = "EOF"
+}
+/** Token with type, value, and position */
+interface Token {
+    type: TokenType;
+    value: string;
+    position: number;
+}
+/** AST Node types */
+type ASTNode = LiteralNode | IdentifierNode | MemberAccessNode | ComputedMemberAccessNode | BinaryOpNode | UnaryOpNode | CallExpressionNode | ConditionalNode | ArrayLiteralNode | ObjectLiteralNode | ArrowFunctionNode;
+interface LiteralNode {
+    type: 'Literal';
+    value: string | number | boolean | null | undefined;
+}
+interface IdentifierNode {
+    type: 'Identifier';
+    name: string;
+}
+interface MemberAccessNode {
+    type: 'MemberAccess';
+    object: ASTNode;
+    property: string;
+    /** True when this access used `?.` (optional chaining). */
+    optional?: boolean;
+}
+interface ComputedMemberAccessNode {
+    type: 'ComputedMemberAccess';
+    object: ASTNode;
+    /** Expression evaluated at runtime to produce the property key. */
+    property: ASTNode;
+    /** True when this access used `?.[ ... ]` (optional chaining). */
+    optional?: boolean;
+}
+interface ConditionalNode {
+    type: 'Conditional';
+    test: ASTNode;
+    consequent: ASTNode;
+    alternate: ASTNode;
+}
+interface BinaryOpNode {
+    type: 'BinaryOp';
+    operator: string;
+    left: ASTNode;
+    right: ASTNode;
+}
+interface UnaryOpNode {
+    type: 'UnaryOp';
+    operator: string;
+    operand: ASTNode;
+}
+interface CallExpressionNode {
+    type: 'CallExpression';
+    callee: ASTNode;
+    arguments: ASTNode[];
+    /** True when this call used `?.( ... )` (optional chaining). */
+    optional?: boolean;
+}
+interface ArrayLiteralNode {
+    type: 'ArrayLiteral';
+    elements: ASTNode[];
+}
+interface ObjectLiteralNode {
+    type: 'ObjectLiteral';
+    properties: Array<{
+        key: string;
+        value: ASTNode;
+    }>;
+}
+interface ArrowFunctionNode {
+    type: 'ArrowFunction';
+    params: string[];
+    body: ASTNode;
+}
+/** Parser error with position information */
+declare class ExpressionParserError extends DynamicFormError {
+    position: number;
+    expression: string;
+    constructor(message: string, position: number, expression: string);
+}
 
-/**
- * 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;
+/** Evaluation context for safe expression evaluation */
+interface EvaluationScope {
+    [key: string]: unknown;
+}
+/** Safely evaluates an AST node with a given context */
+declare class Evaluator {
+    private readonly scope;
+    private readonly expression;
+    constructor(scope: EvaluationScope, expression: string);
+    /** Evaluate an AST node */
+    evaluate(node: ASTNode): unknown;
+    private evaluateIdentifier;
+    private evaluateMemberAccess;
+    private evaluateComputedMemberAccess;
+    private evaluateBinaryOp;
+    private evaluateUnaryOp;
+    private evaluateCallExpression;
+    private evaluateArrayLiteral;
+    private evaluateObjectLiteral;
+    private evaluateArrowFunction;
+    private isMethodSafe;
 }
 
-/**
- * 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> {
+/** Secure expression parser that uses AST-based evaluation */
+declare class ExpressionParser {
     /**
-     * Action called when the form is submitted.
-     *
-     * @param form - The form's FieldTree instance
-     * @returns Promise or Observable - for errors, return TreeValidationResult
+     * Parse an expression string into an AST
+     * Results are cached for performance using LRU eviction
      */
-    action: (form: FieldTree<TValue>) => SubmissionActionResult;
+    static parse(expression: string): ASTNode;
+    /** Evaluate an expression with a given scope */
+    static evaluate(expression: string, scope: EvaluationScope): unknown;
+    /** Clear the AST cache */
+    static clearCache(): void;
+    /** Get cache statistics */
+    static getCacheStats(): {
+        size: number;
+        maxSize: number;
+    };
 }
 
 /**
- * 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)
+ * Parses tokens into an Abstract Syntax Tree (AST)
+ * Uses recursive descent parsing with operator precedence
  */
-interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue<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 {
+declare class Parser {
+    private tokens;
+    private current;
+    private readonly expression;
+    constructor(expression: string);
+    /** Parse the expression into an AST */
+    parse(): ASTNode;
+    private parseExpression;
     /**
-     * Disable next button when the current page has invalid fields.
-     *
-     * @default true
+     * Ternary `test ? consequent : alternate` — right-associative, sits between
+     * the arrow-function check and logical-or in precedence.
      */
-    disableWhenPageInvalid?: boolean;
+    private parseConditional;
     /**
-     * Disable next button while the form is submitting.
-     *
-     * @default true
+     * Attempts to parse an arrow function. Returns null and leaves position
+     * unchanged if the next tokens don't form an arrow function head.
      */
-    disableWhileSubmitting?: boolean;
+    private tryParseArrowFunction;
+    private checkAt;
+    private parseLogicalOr;
+    private parseLogicalAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseAddition;
+    private parseMultiplication;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseArgumentList;
+    private parseArrayElements;
+    private parseObjectProperties;
+    private match;
+    private check;
+    private advance;
+    private isAtEnd;
+    private peek;
+    private previous;
+    private consume;
 }
 
-/** 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;
+/** Tokenizes an expression string into tokens */
+declare class Tokenizer {
+    private position;
+    private readonly expression;
+    constructor(expression: string);
+    /** Tokenize the entire expression */
+    tokenize(): Token[];
+    private skipWhitespace;
+    private nextToken;
+    private readString;
+    private readNumber;
+    private readIdentifierOrKeyword;
+    private getKeywordType;
+    private readOperatorOrPunctuation;
 }
-/**
- * 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;
+
+/** TTL cache for HTTP condition responses with max entries eviction. */
+declare class HttpConditionCache {
+    private readonly cache;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    get(key: string): boolean | undefined;
+    set(key: string, value: boolean, ttlMs: number): void;
+    clear(): void;
 }
+/** @internal */
+declare const HTTP_CONDITION_CACHE: InjectionToken<HttpConditionCache>;
+
 /**
- * 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
+ * Resolves an `HttpRequestConfig` into an `HttpResourceRequest` by evaluating
+ * expression-based query params and (optionally) body values.
  */
-declare function resolveNonFieldDisabled(ctx: NonFieldLogicContext): Signal<boolean>;
+declare function resolveHttpRequest(config: HttpRequestConfig, context: EvaluationContext): HttpResourceRequest | null;
+
+/** Evaluates an HTTP response against a `HttpValidationResponseMapping` to produce a validation result. */
+declare function evaluateHttpValidationResponse(response: unknown, mapping: HttpValidationResponseMapping, logger: Logger): ValidationError$1 | null;
 
 /**
  * Service that provides field evaluation context by combining
@@ -2903,142 +3222,22 @@ declare function pageFieldMapper(fieldDef: PageField): Signal<Record<string, unk
  */
 declare function textFieldMapper(fieldDef: TextField): Signal<Record<string, unknown>>;
 
+/** Handler signature for user-registered addon actions. */
+type AddonActionHandler<TValue = unknown> = (ctx: AddonActionContext<TValue>) => void;
 /**
- * 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;
-
-/**
- * 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.
+ * Multi-provider token populated by `withAddonActions({...})` calls.
+ * `ADDON_ACTION_REGISTRY` aggregates these into a single name → handler map.
+ *
+ * @internal
  */
-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;
-}
+declare const ADDON_ACTION_HANDLERS: InjectionToken<readonly Record<string, AddonActionHandler<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.
+ * Form-scoped name → handler map. Read by adapter button types at click
+ * time for `actionRef: 'name'` lookups. Provided at form scope (not root)
+ * because `ADDON_ACTION_HANDLERS` is form-scoped via `withAddonActions`.
  */
-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>>>>;
+declare const ADDON_ACTION_REGISTRY: InjectionToken<ReadonlyMap<string, AddonActionHandler<unknown>>>;
+declare function createAddonActionRegistry(): ReadonlyMap<string, AddonActionHandler>;
 
 /**
  * Map of named `TemplateRef`s collected by `<df-dynamic-form>` from
@@ -3483,26 +3682,5 @@ declare function safeReadPathKeys(fieldContext: FieldContext<unknown>): readonly
  */
 declare function stableStringify(value: unknown): string;
 
-/** 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;
-}
-
-export { ADDON_KIND_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, Evaluator, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, Parser, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, Tokenizer, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyHiddenLogic, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAsyncConditionLogicFunction, createDebouncedLogicFunction, createDebouncedResourceLogicFn, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createHttpConditionLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateHttpValidationResponse, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectFieldSignalContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isContainerTypedField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, safeReadPathKeys, setupInitializationTracking, shouldLog, stableStringify, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
-export type { ASTNode, AddonActionContext, AddonActionPreset, AddonKindDefinition, AddonKindSchema, AddonShapeValidator, AddonSlot, AndCondition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayComponent, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemDefinition, ArrayItemTemplate, ArrayLiteralNode, ArrowFunctionNode, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BinaryOpNode, BuiltInValidatorConfig, ButtonLogicContext, CallExpressionNode, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComparisonOperator, ComponentAddon, ComputedMemberAccessNode, ConditionalExpression, ConditionalNode, ContainerAllowedChildren, ContainerComponent, ContainerField, ContainerFieldTypes, ContainerLogicConfig, CrossFieldDetectionContext, CssWrapper, CustomCondition, CustomFnConfig, CustomFunction, CustomFunctionOptions, CustomFunctionScope, CustomValidator, CustomValidatorConfig, DebouncedResourceLogicFnConfig, DeclarativeHttpValidatorConfig, DerivationLogConfig, DerivationLogLevel, DerivationLogicConfig, DerivedFromDeferredOptions, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, EvaluationScope, ExtractField, FieldAddonSupport, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTreeRecord, FieldTypeDefinition, FieldValueCondition, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, FunctionHttpValidatorConfig, GroupAllowedChildren, GroupComponent, GroupContext, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, IdentifierNode, InferFormValue, InitializationTrackingOptions, JavascriptCondition, LazyComponentLoader, LeafFieldTypes, LiteralNode, Logger, LogicConfig, LogicTrigger, MapperFn, MemberAccessNode, MemoizeOptions, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, ObjectLiteralNode, OrCondition, OrphanAddonActionContext, PageAllowedChildren, PageField, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, RegisteredWrapperTypes, RenderReadyInput, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowComponent, RowField, RowWrapper, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, StateLogicType, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, Token, TokenContext, Trigger, UnaryOpNode, ValidationError, ValidationExecutionConfig, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WarningTracker, WithInputSignals, WrapperAutoAssociations, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition };
+export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, Evaluator, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, Parser, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, Tokenizer, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyHiddenLogic, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAddonActionRegistry, createAsyncConditionLogicFunction, createDebouncedLogicFunction, createDebouncedResourceLogicFn, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createHttpConditionLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateHttpValidationResponse, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, runPresetAction, safeReadPathKeys, setupInitializationTracking, shouldLog, stableStringify, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
+export type { ASTNode, AddonActionContext, AddonActionHandler, AddonActionPreset, AddonShapeValidator, AddonSlot, AddonTypeDefinition, AddonTypeRegistryRef, AddonTypeSchema, AndCondition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayComponent, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemDefinition, ArrayItemTemplate, ArrayLiteralNode, ArrowFunctionNode, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BinaryOpNode, BuiltInValidatorConfig, ButtonLogicContext, CallExpressionNode, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComparisonOperator, ComponentAddon, ComputedMemberAccessNode, ConditionalExpression, ConditionalNode, ContainerAllowedChildren, ContainerComponent, ContainerField, ContainerFieldTypes, ContainerLogicConfig, CrossFieldDetectionContext, CssWrapper, CustomCondition, CustomFnConfig, CustomFunction, CustomFunctionOptions, CustomFunctionScope, CustomValidator, CustomValidatorConfig, DebouncedResourceLogicFnConfig, DeclarativeHttpValidatorConfig, DerivationLogConfig, DerivationLogLevel, DerivationLogicConfig, DerivedFromDeferredOptions, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormFieldRegistry, DynamicText, DynamicValue, EvaluationContext, EvaluationScope, ExtractField, FieldAddonSupport, FieldAddonSupportEntry, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTreeRecord, FieldTypeDefinition, FieldValueCondition, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, FunctionHttpValidatorConfig, GroupAllowedChildren, GroupComponent, GroupContext, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, IdentifierNode, InferFormValue, InitializationTrackingOptions, JavascriptCondition, LazyComponentLoader, LeafFieldTypes, LiteralNode, Logger, LogicConfig, LogicTrigger, MapperFn, MemberAccessNode, MemoizeOptions, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, ObjectLiteralNode, OrCondition, OrphanAddonActionContext, PageAllowedChildren, PageField, PresetCollaborators, Prettify, ReadonlyFieldTree, RegisteredActionRef, RegisteredFieldTypes, RegisteredWrapperTypes, RenderReadyInput, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowComponent, RowField, RowWrapper, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, StateLogicType, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, Token, TokenContext, Trigger, UnaryOpNode, ValidationError, ValidationExecutionConfig, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WarningTracker, WithInputSignals, WrapperAutoAssociations, WrapperConfig, WrapperFieldInputs, WrapperTypeDefinition };