@ng-forge/dynamic-forms 0.10.0-next.2 → 0.10.0-next.4

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

@@ -0,0 +1,3508 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { FieldContext, TreeValidationResult, ValidationError as ValidationError$1, FieldTree, FieldState, 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';
+
+/**
+ * Interface for dynamic forms logger implementations.
+ * Allows custom logging integrations (Sentry, DataDog, etc.)
+ */
+interface Logger {
+    /**
+     * Log a debug message.
+     * Use for detailed diagnostic information during development.
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Log an info message.
+     * Use for general operational information.
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message.
+     * Use for potentially problematic situations that don't prevent operation.
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message.
+     * Use for error conditions that may affect functionality.
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+
+/**
+ * Shared shape for DI-scoped warning trackers that dedupe log output.
+ *
+ * @internal
+ */
+interface WarningTracker {
+    warnedKeys: Set<string>;
+}
+/**
+ * Creates a fresh warning tracker instance with an empty key set.
+ * DI-scoped per form instance — never module-scoped (SSR-unsafe).
+ *
+ * @internal
+ */
+declare function createWarningTracker(): WarningTracker;
+
+/** Represents the state information of a single form field. */
+interface FieldStateInfo {
+    readonly touched: boolean;
+    readonly dirty: boolean;
+    /** Convenience property: equivalent to `!dirty` */
+    readonly pristine: boolean;
+    readonly valid: boolean;
+    readonly invalid: boolean;
+    readonly pending: boolean;
+    /** Whether the field is currently hidden. */
+    readonly hidden: boolean;
+    /** Whether the field is currently readonly. */
+    readonly readonly: boolean;
+    /** Whether the field is currently disabled. */
+    readonly disabled: boolean;
+}
+/** Map of field keys to their state information. */
+type FormFieldStateMap = Record<string, FieldStateInfo | undefined>;
+/** Field state context for the current field being evaluated. */
+type FieldStateContext = FieldStateInfo;
+
+interface EvaluationContext<TValue = unknown, TFormValue extends Record<string, unknown> = any> {
+    /** Current field value */
+    fieldValue: TValue;
+    /** Form value for the current evaluation scope. */
+    formValue: TFormValue;
+    /** Field path for relative references */
+    fieldPath: string;
+    /** Custom evaluation functions */
+    customFunctions?: Record<string, (context: EvaluationContext) => unknown>;
+    /** Logger for diagnostic output */
+    logger: Logger;
+    /**
+     * Value of the field's nearest parent **group** (or array item, when the
+     * field has no inner group above the array boundary).
+     */
+    groupValue?: unknown;
+    /** Root form value when inside an array context. */
+    rootFormValue?: Record<string, unknown>;
+    /** Current array index when inside an array derivation. */
+    arrayIndex?: number;
+    /** Path to the array field when inside an array derivation. */
+    arrayPath?: string;
+    /** External data signals resolved to their current values. */
+    externalData?: Record<string, unknown>;
+    /**
+     * DI-scoped tracker for deprecation warnings.
+     * Used by the condition evaluator to deduplicate deprecation warnings.
+     */
+    deprecationTracker?: WarningTracker;
+    /** State of the current field being evaluated. */
+    fieldState?: FieldStateContext;
+    /** State of all fields in the form, keyed by field key. */
+    formFieldState?: FormFieldStateMap;
+    /** Allow additional properties for flexible expression evaluation */
+    [key: string]: unknown;
+}
+
+/** Scope of a custom function. */
+type CustomFunctionScope = 'field' | 'form';
+/** Options for registering a custom function. */
+interface CustomFunctionOptions {
+    /**
+     * The scope of the function.
+     *
+     * @default 'form'
+     */
+    scope?: CustomFunctionScope;
+}
+/** Custom function signature for conditional expressions */
+type CustomFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => unknown;
+
+/** Async function for derivations — returns any value. */
+type AsyncDerivationFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<unknown> | Observable<unknown>;
+/** Async function for conditions — returns boolean. */
+type AsyncConditionFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<boolean> | Observable<boolean>;
+
+/** Configuration for an HTTP request used by declarative HTTP validators, derivations, and conditions. */
+interface HttpRequestConfig {
+    /** URL to send the request to */
+    url: string;
+    /** HTTP method. Defaults to 'GET' */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * URL path parameters. Keys correspond to `:key` placeholders in the URL.
+     * Values are expressions evaluated by ExpressionParser against the current EvaluationContext.
+     */
+    params?: Record<string, string>;
+    /**
+     * Query parameters appended to the URL.
+     * Values are expressions evaluated by ExpressionParser against the current EvaluationContext.
+     */
+    queryParams?: Record<string, string>;
+    /** Request body (for POST/PUT/PATCH) */
+    body?: Record<string, unknown>;
+    /**
+     * When true, top-level string values in `body` are treated as expressions
+     * and evaluated by ExpressionParser (shallow only — nested objects are passed through as-is).
+     */
+    evaluateBodyExpressions?: boolean;
+    /** HTTP headers to include in the request */
+    headers?: Record<string, string>;
+}
+
+/** Comparison operators for field value and form value conditions. */
+type ComparisonOperator = 'equals' | 'notEquals' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual' | 'contains' | 'startsWith' | 'endsWith' | 'matches';
+/** Condition that compares a specific field's value against an expected value. */
+interface FieldValueCondition {
+    type: 'fieldValue';
+    /** Path to the field whose value to compare */
+    fieldPath: string;
+    /** Comparison operator */
+    operator: ComparisonOperator;
+    /** Value to compare against */
+    value?: unknown;
+}
+/** Condition that invokes a custom function. */
+type CustomCondition = {
+    type: 'custom';
+    /** Name of the registered custom function to invoke */
+    functionName: string;
+    /** Inline form is forbidden when `functionName` is set */
+    fn?: never;
+} | {
+    type: 'custom';
+    /** Inline custom function. Mutually exclusive with `functionName`. */
+    fn: CustomFunction;
+    /** Registered form is forbidden when `fn` is set */
+    functionName?: never;
+};
+/** Condition that evaluates a JavaScript expression using the secure AST-based parser. */
+interface JavascriptCondition {
+    type: 'javascript';
+    /** JavaScript expression string to evaluate */
+    expression: string;
+}
+/** Condition that evaluates based on an HTTP response from a remote server. */
+interface HttpCondition {
+    type: 'http';
+    /** HTTP request configuration */
+    http: HttpRequestConfig;
+    /**
+     * Expression to extract boolean from response (scope: `{ response }`).
+     * e.g. `'response.allowed'`, `'response.permissions.canEdit'`
+     * When omitted, the entire response is coerced to boolean: `!!response`
+     */
+    responseExpression?: string;
+    /**
+     * Value to return while the HTTP request is in-flight.
+     *
+     * @default false
+     */
+    pendingValue?: boolean;
+    /** Cache duration in ms for HTTP responses. @default 30000 */
+    cacheDurationMs?: number;
+    /**
+     * Debounce time in milliseconds for re-evaluation when dependent form values change.
+     *
+     * @default 300
+     */
+    debounceMs?: number;
+}
+/**
+ * Shared fields for both branches of {@link AsyncCondition}.
+ *
+ * @internal
+ */
+interface AsyncConditionBase {
+    type: 'async';
+    /**
+     * Value to return while async resolution is pending.
+     *
+     * @default false
+     */
+    pendingValue?: boolean;
+    /**
+     * Debounce ms for re-evaluation.
+     *
+     * @default 300
+     */
+    debounceMs?: number;
+}
+/** Condition that resolves asynchronously via a custom function. */
+type AsyncCondition = (AsyncConditionBase & {
+    /** Name of the registered async condition function */
+    asyncFunctionName: string;
+    /** Inline form is forbidden when `asyncFunctionName` is set */
+    asyncFn?: never;
+}) | (AsyncConditionBase & {
+    /** Inline async condition function. Mutually exclusive with `asyncFunctionName`. */
+    asyncFn: AsyncConditionFunction;
+    /** Registered form is forbidden when `asyncFn` is set */
+    asyncFunctionName?: never;
+});
+/** Logical AND — all sub-conditions must be true. */
+interface AndCondition {
+    type: 'and';
+    /** Sub-conditions that must all evaluate to true */
+    conditions: ConditionalExpression[];
+}
+/** Logical OR — at least one sub-condition must be true. */
+interface OrCondition {
+    type: 'or';
+    /** Sub-conditions where at least one must evaluate to true */
+    conditions: ConditionalExpression[];
+}
+/** Discriminated union of all conditional expression types. */
+type ConditionalExpression = FieldValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
+
+/** Special form-state conditions for button disabled logic. */
+type FormStateCondition = 
+/** True when form.valid() === false */
+'formInvalid'
+/** True when form.submitting() === true */
+ | 'formSubmitting'
+/** True when fields on the current page are invalid (for paged forms) */
+ | 'pageInvalid';
+/** Logic type for controlling field state (hidden, readonly, disabled, required). */
+type StateLogicType = 'hidden' | 'readonly' | 'disabled' | 'required';
+/**
+ * Base configuration for conditional field state logic.
+ *
+ * @internal
+ */
+interface BaseStateLogicConfig {
+    /** Logic type identifier for field state. */
+    type: StateLogicType;
+    /** Condition that determines when this logic applies. */
+    condition: ConditionalExpression | boolean | FormStateCondition;
+}
+/**
+ * State logic that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+interface ImmediateStateLogicConfig extends BaseStateLogicConfig {
+    /**
+     * Trigger for immediate evaluation.
+     *
+     * @default 'onChange'
+     */
+    trigger?: 'onChange';
+    /** Not allowed for onChange trigger */
+    debounceMs?: never;
+}
+/**
+ * State logic that evaluates after a debounce period.
+ *
+ * @internal
+ */
+interface DebouncedStateLogicConfig extends BaseStateLogicConfig {
+    /**
+     * Trigger for debounced evaluation.
+     * Evaluates after the value has stabilized for the debounce duration.
+     */
+    trigger: 'debounced';
+    /**
+     * Debounce duration in milliseconds.
+     *
+     * @default 500
+     */
+    debounceMs?: number;
+}
+/** Configuration for conditional field state logic. */
+type StateLogicConfig = ImmediateStateLogicConfig | DebouncedStateLogicConfig;
+/** 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;
+    /**
+     * When true, the derivation stops running after the user manually
+     * edits the target field.
+     */
+    stopOnUserOverride?: boolean;
+    /**
+     * When true (and `stopOnUserOverride` is also true), clears the
+     * user-override flag when any dependency of this derivation changes,
+     * allowing the derivation to run again.
+     */
+    reEngageOnDependencyChange?: boolean;
+}
+/**
+ * Trigger variants for derivation timing.
+ *
+ * @internal
+ */
+type ImmediateDerivationTrigger = {
+    trigger?: 'onChange';
+    debounceMs?: never;
+};
+type DebouncedDerivationTrigger = {
+    trigger: 'debounced';
+    debounceMs?: number;
+};
+/**
+ * Base for HTTP derivations. `source: 'http'` is required.
+ * TypeScript enforces `dependsOn` and `responseExpression` at the type level.
+ *
+ * @internal
+ */
+interface HttpDerivationBase extends SharedDerivationFields {
+    /** Identifies this derivation as HTTP-driven. */
+    source: 'http';
+    /** Forbidden on HTTP source */
+    fn?: never;
+    /** Forbidden on HTTP source */
+    asyncFn?: never;
+    /** HTTP request configuration for server-driven derivations. */
+    http: HttpRequestConfig;
+    /**
+     * Explicit field dependencies. Required for HTTP derivations to prevent
+     * wildcard triggering on every keystroke.
+     */
+    dependsOn: string[];
+    /** Expression to extract the derived value from the HTTP response. */
+    responseExpression: string;
+    value?: never;
+    expression?: never;
+    functionName?: never;
+    asyncFunctionName?: never;
+}
+/**
+ * Shared fields for both branches of {@link AsyncFunctionDerivationBase}.
+ *
+ * @internal
+ */
+interface AsyncFunctionDerivationShared extends SharedDerivationFields {
+    /** Identifies this derivation as async-function-driven. */
+    source: 'asyncFunction';
+    /** Forbidden on asyncFunction source */
+    fn?: never;
+    /**
+     * Explicit field dependencies. Required for async derivations to prevent
+     * wildcard triggering on every form change.
+     */
+    dependsOn: string[];
+    value?: never;
+    expression?: never;
+    functionName?: never;
+    http?: never;
+    responseExpression?: never;
+}
+/**
+ * Base for async function derivations. `source: 'asyncFunction'` is required.
+ * TypeScript enforces `dependsOn` at the type level, and `asyncFunctionName` /
+ * `asyncFn` are mutually exclusive (XOR).
+ *
+ * @internal
+ */
+type AsyncFunctionDerivationBase = (AsyncFunctionDerivationShared & {
+    /** Name of a registered async derivation function. */
+    asyncFunctionName: string;
+    /** Inline form is forbidden when `asyncFunctionName` is set */
+    asyncFn?: never;
+}) | (AsyncFunctionDerivationShared & {
+    /** Inline async derivation function. Mutually exclusive with `asyncFunctionName`. */
+    asyncFn: AsyncDerivationFunction;
+    /** Registered form is forbidden when `asyncFn` is set */
+    asyncFunctionName?: never;
+});
+/**
+ * Base for expression derivations.
+ *
+ * @internal
+ */
+interface ExpressionDerivationBase extends SharedDerivationFields {
+    source?: never;
+    /** Forbidden on expression mode */
+    fn?: never;
+    /** Forbidden on expression mode */
+    asyncFn?: never;
+    /** JavaScript expression to evaluate for the derived value. */
+    expression: string;
+    /** Explicit field dependencies for expressions. */
+    dependsOn?: string[];
+    value?: never;
+    functionName?: never;
+    http?: never;
+    asyncFunctionName?: never;
+    responseExpression?: never;
+}
+/**
+ * Base for value derivations.
+ *
+ * @internal
+ */
+interface ValueDerivationBase extends SharedDerivationFields {
+    source?: never;
+    /** Forbidden on value mode */
+    fn?: never;
+    /** Forbidden on value mode */
+    asyncFn?: never;
+    /** Static value to set on this field. */
+    value: unknown;
+    /** Explicit field dependencies for value derivations. */
+    dependsOn?: string[];
+    expression?: never;
+    functionName?: never;
+    http?: never;
+    asyncFunctionName?: never;
+    responseExpression?: never;
+}
+/**
+ * Shared fields for both branches of {@link FunctionDerivationBase}.
+ *
+ * @internal
+ */
+interface FunctionDerivationShared extends SharedDerivationFields {
+    source?: never;
+    /** Forbidden on function-derivation mode */
+    asyncFn?: never;
+    /** Explicit field dependencies for function derivations. */
+    dependsOn?: string[];
+    value?: never;
+    expression?: never;
+    http?: never;
+    asyncFunctionName?: never;
+    responseExpression?: never;
+}
+/**
+ * Base for custom sync function derivations. `functionName` and `fn` are
+ * mutually exclusive (XOR).
+ *
+ * @internal
+ */
+type FunctionDerivationBase = (FunctionDerivationShared & {
+    /** Name of a registered custom derivation function. */
+    functionName: string;
+    /** Inline form is forbidden when `functionName` is set */
+    fn?: never;
+}) | (FunctionDerivationShared & {
+    /** Inline custom derivation function. Mutually exclusive with `functionName`. */
+    fn: CustomFunction;
+    /** Registered form is forbidden when `fn` is set */
+    functionName?: never;
+});
+/**
+ * HTTP derivation that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+type OnChangeHttpDerivationLogicConfig = HttpDerivationBase & ImmediateDerivationTrigger;
+/**
+ * HTTP derivation that evaluates after a debounce period.
+ *
+ * @internal
+ */
+type DebouncedHttpDerivationLogicConfig = HttpDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Async function derivation that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+type OnChangeAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Async function derivation that evaluates after a debounce period.
+ *
+ * @internal
+ */
+type DebouncedAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Expression derivation that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+type OnChangeExpressionDerivationLogicConfig = ExpressionDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Expression derivation that evaluates after a debounce period.
+ *
+ * @internal
+ */
+type DebouncedExpressionDerivationLogicConfig = ExpressionDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Value derivation that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+type OnChangeValueDerivationLogicConfig = ValueDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Value derivation that evaluates after a debounce period.
+ *
+ * @internal
+ */
+type DebouncedValueDerivationLogicConfig = ValueDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Function derivation that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+type OnChangeFunctionDerivationLogicConfig = FunctionDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Function derivation that evaluates after a debounce period.
+ *
+ * @internal
+ */
+type DebouncedFunctionDerivationLogicConfig = FunctionDerivationBase & DebouncedDerivationTrigger;
+/** Configuration for value derivation logic. */
+type DerivationLogicConfig = OnChangeHttpDerivationLogicConfig | DebouncedHttpDerivationLogicConfig | OnChangeAsyncFunctionDerivationLogicConfig | DebouncedAsyncFunctionDerivationLogicConfig | OnChangeExpressionDerivationLogicConfig | DebouncedExpressionDerivationLogicConfig | OnChangeValueDerivationLogicConfig | DebouncedValueDerivationLogicConfig | OnChangeFunctionDerivationLogicConfig | DebouncedFunctionDerivationLogicConfig;
+/** Union type for all logic configurations. */
+type LogicConfig = StateLogicConfig | DerivationLogicConfig;
+/** Log level for derivation debug output. */
+type DerivationLogLevel = 'none' | 'summary' | 'verbose';
+/** 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;
+};
+
+/**
+ * Custom validator function signature using Angular's public FieldContext API
+ *
+ * @template TValue The type of value stored in the field being validated
+ */
+type CustomValidator<TValue = unknown> = (ctx: FieldContext<TValue>, params?: Record<string, unknown>) => ValidationError$1 | ValidationError$1[] | null;
+/**
+ * Async custom validator configuration using Angular's resource-based API
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TParams The type of params passed to the resource
+ * @template TResult The type of result returned by the resource
+ */
+interface AsyncCustomValidator<TValue = unknown, TParams = unknown, TResult = unknown> {
+    /**
+     * Function that receives field context and returns resource params.
+     * Params will be tracked as a signal and trigger resource reload when changed.
+     */
+    readonly params: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => TParams;
+    /**
+     * Function that creates a ResourceRef from the params signal.
+     * The resource will be automatically managed by Angular's lifecycle.
+     */
+    readonly factory: (params: Signal<TParams | undefined>) => ResourceRef<TResult | undefined>;
+    /**
+     * Optional function to map successful resource result to validation errors.
+     * Return null if validation passes, or ValidationError/ValidationError[] if validation fails.
+     */
+    readonly onSuccess?: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
+    /**
+     * Optional error handler for resource errors (network failures, etc.).
+     * Return null to ignore the error, or ValidationError to display it to the user.
+     */
+    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
+}
+/** HTTP request configuration for validateHttp API */
+interface HttpResourceRequest {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    headers?: Record<string, string | string[]>;
+}
+/**
+ * HTTP-based validator configuration for Angular's validateHttp API
+ *
+ * @template TValue The type of value stored in the field being validated
+ * @template TResult The type of HTTP response
+ */
+interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
+    /**
+     * Function that returns the HTTP request configuration.
+     * Can return:
+     * - `undefined` to skip validation (e.g., if field is empty)
+     * - `string` for simple GET requests (just the URL)
+     * - `HttpResourceRequest` for full control (method, body, headers)
+     */
+    readonly request: (ctx: FieldContext<TValue>, config?: Record<string, unknown>) => string | HttpResourceRequest | undefined;
+    /** REQUIRED function to map successful HTTP response to validation errors. */
+    readonly onSuccess: (result: TResult, ctx: FieldContext<TValue>) => TreeValidationResult;
+    /**
+     * Optional error handler for HTTP errors (network failures, 4xx/5xx status codes).
+     * Return null to ignore the error, or ValidationError to display it to the user.
+     */
+    readonly onError?: (error: unknown, ctx: FieldContext<TValue>) => ValidationError$1 | ValidationError$1[] | null;
+}
+
+/** Mapping configuration for interpreting HTTP responses as validation results. */
+interface HttpValidationResponseMapping {
+    /** Expression evaluated with scope `{ response }`. Must evaluate to `true` (strict boolean) to be valid. */
+    validWhen: string;
+    /** Error kind returned when validation fails — maps to field-level `validationMessages` */
+    errorKind: string;
+    /**
+     * Parameters to include in the validation error for message interpolation.
+     * Map of parameter names to expressions evaluated against `{ response }`.
+     */
+    errorParams?: Record<string, string>;
+}
+
+/** Base configuration shared by all validators */
+interface BaseValidatorConfig {
+    /** Conditional logic for when validator applies */
+    when?: ConditionalExpression;
+}
+/** Built-in validator configuration (required, email, min, max, etc.) */
+interface BuiltInValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
+    /** Static value for the validator (e.g., min value, pattern) */
+    value?: number | string | RegExp;
+    /** Dynamic value expression that evaluates to validator parameter */
+    expression?: string;
+}
+/**
+ * Custom validator configuration using Angular's public FieldContext API.
+ * Returns ValidationError | ValidationError[] | null synchronously.
+ */
+interface CustomValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'custom';
+    /** Name of registered validator function (function-based pattern) */
+    functionName?: string;
+    /**
+     * Inline custom validator (code-only authoring).
+     * Mutually exclusive with `functionName`. NOT JSON-serializable.
+     */
+    fn?: CustomValidator;
+    /** Optional parameters to pass to validator function */
+    params?: Record<string, unknown>;
+    /** JavaScript expression to evaluate (expression-based pattern) */
+    expression?: string;
+    /** Error kind for expression-based validators - links to validationMessages */
+    kind?: string;
+    /**
+     * Parameters to include in error object for message interpolation (expression-based pattern)
+     * Map of parameter names to expressions that will be evaluated in the same context as the validation expression
+     */
+    errorParams?: Record<string, string>;
+}
+/**
+ * Shared fields for both branches of {@link AsyncValidatorConfig}.
+ *
+ * @internal
+ */
+interface AsyncValidatorConfigShared extends BaseValidatorConfig {
+    /** Validator type identifier. */
+    type: 'async';
+    /** Optional parameters to pass to validator function */
+    params?: Record<string, unknown>;
+}
+/**
+ * Async custom validator configuration using Angular's `validateAsync` API.
+ * Returns Observable<ValidationError | ValidationError[] | null>.
+ */
+type AsyncValidatorConfig = (AsyncValidatorConfigShared & {
+    /** Name of registered async validator function */
+    functionName: string;
+    /** Inline form is forbidden when `functionName` is set */
+    fn?: never;
+}) | (AsyncValidatorConfigShared & {
+    /** Inline async validator. Mutually exclusive with `functionName`. */
+    fn: AsyncCustomValidator;
+    /** Registered form is forbidden when `fn` is set */
+    functionName?: never;
+});
+/**
+ * Shared fields for both branches of {@link FunctionHttpValidatorConfig}.
+ *
+ * @internal
+ */
+interface FunctionHttpValidatorConfigShared extends BaseValidatorConfig {
+    /** Validator type identifier. */
+    type: 'http';
+    /** Optional parameters to pass to HTTP validator */
+    params?: Record<string, unknown>;
+}
+/** Function-based HTTP validator configuration. Uses Angular's `validateHttp` API. */
+type FunctionHttpValidatorConfig = (FunctionHttpValidatorConfigShared & {
+    /** Name of registered HTTP validator configuration */
+    functionName: string;
+    /** Inline form is forbidden when `functionName` is set */
+    fn?: never;
+}) | (FunctionHttpValidatorConfigShared & {
+    /** Inline HTTP validator. Mutually exclusive with `functionName`. */
+    fn: HttpCustomValidator;
+    /** Registered form is forbidden when `fn` is set */
+    functionName?: never;
+});
+/** Declarative HTTP validator configuration — fully JSON-serializable, no function registration required. */
+interface DeclarativeHttpValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'http';
+    /** HTTP request configuration with expression-based query params and body */
+    http: HttpRequestConfig;
+    /** Mapping that interprets the HTTP response as a validation result */
+    responseMapping: HttpValidationResponseMapping;
+}
+/**
+ * Configuration for signal forms validator functions that can be serialized from API.
+ * Discriminated union type for type-safe validator configuration.
+ */
+type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig;
+/** 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;
+}
+/**
+ * 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 isCrossFieldExpression(expr: ConditionalExpression | boolean | FormStateCondition | undefined, context?: CrossFieldDetectionContext): boolean;
+/**
+ * Extracts field dependencies from a ConditionalExpression.
+ *
+ * @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']).
+ */
+declare function extractStringDependencies(expression: string): string[];
+/**
+ * Detects if a custom validator configuration references formValue (cross-field validation).
+ *
+ * @param config The custom validator configuration to check
+ * @returns true if the validator references formValue
+ */
+declare function isCrossFieldValidator(config: CustomValidatorConfig): boolean;
+/**
+ * Detects if a built-in validator has a dynamic expression that references formValue.
+ *
+ * @param config The validator configuration to check
+ * @returns true if the validator has a cross-field dynamic expression
+ */
+declare function isCrossFieldBuiltInValidator(config: ValidatorConfig): boolean;
+/** Checks if a validator uses Angular's resource API (validateHttp / validateAsync). */
+declare function isResourceBasedValidator(config: ValidatorConfig): boolean;
+/**
+ * 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
+ */
+declare function hasCrossFieldWhenCondition(config: ValidatorConfig, context?: CrossFieldDetectionContext): boolean;
+/**
+ * Detects if a StateLogicConfig has a cross-field condition.
+ *
+ * @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
+ */
+declare function isCrossFieldStateLogic(config: StateLogicConfig, context?: CrossFieldDetectionContext): boolean;
+/**
+ * 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
+ */
+declare function isCrossFieldSchema(config: SchemaApplicationConfig, context?: CrossFieldDetectionContext): boolean;
+
+/**
+ * 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
+ */
+declare function readFieldStateInfo(fieldSource: FieldTree<unknown> | FieldState<unknown> | undefined, reactive: boolean): FieldStateInfo | undefined;
+/**
+ * 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
+ */
+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>;
+
+/**
+ * Evaluate conditional expression
+ * Uses secure AST-based parsing for JavaScript expressions
+ */
+declare function evaluateCondition(expression: ConditionalExpression, context: EvaluationContext): boolean;
+
+/**
+ * Trigger value carried through the debounced reactive pipeline.
+ *
+ * @internal
+ */
+interface Trigger<TPayload> {
+    key: string;
+    payload: TPayload;
+}
+/**
+ * Configuration passed to {@link createDebouncedResourceLogicFn}.
+ *
+ * @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';
+    };
+}
+/**
+ * Shared scaffolding for both async-function and HTTP condition LogicFns.
+ *
+ * @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>;
+
+/**
+ * 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
+ */
+declare function createLogicFunction<TValue>(expression: ConditionalExpression): LogicFn<TValue, boolean>;
+/**
+ * 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
+ */
+declare function createDebouncedLogicFunction<TValue>(expression: ConditionalExpression, debounceMs: number): LogicFn<TValue, boolean>;
+
+/**
+ * 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
+ */
+declare function compareValues(actual: unknown, expected: unknown, operator: string): boolean;
+/**
+ * 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
+ */
+declare function getNestedValue(obj: unknown, path: string): unknown;
+/**
+ * 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)
+ */
+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);
+}
+
+/** 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;
+}
+
+/** Secure expression parser that uses AST-based evaluation */
+declare class ExpressionParser {
+    /**
+     * Parse an expression string into an AST
+     * Results are cached for performance using LRU eviction
+     */
+    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;
+    };
+}
+
+/**
+ * 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;
+    /**
+     * Ternary `test ? consequent : alternate` — right-associative, sits between
+     * the arrow-function check and logical-or in precedence.
+     */
+    private parseConditional;
+    /**
+     * Attempts to parse an arrow function. Returns null and leaves position
+     * unchanged if the next tokens don't form an arrow function head.
+     */
+    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;
+}
+
+/** 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;
+}
+
+/** 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[]>;
+}
+/**
+ * Build a `ReadonlyFieldTree` by extracting the whitelisted read signals from a
+ * Signal Forms `FieldTree`. Returns a fresh plain object — no casting, no proxying,
+ * so consumers only see the narrow surface and Angular's `WritableSignal` capability
+ * on `value` is hidden.
+ */
+declare function toReadonlyFieldTree<TValue>(field: FieldTree<TValue>): ReadonlyFieldTree<TValue>;
+/**
+ * Write a value into a FieldTree's underlying signal. Signal Forms stores
+ * `FieldState.value` as a `WritableSignal`; this helper centralises the cast
+ * and warns if that contract ever changes (vs a silent no-op).
+ */
+declare function writeToFieldValue<T>(value: Signal<T>, next: T, logger?: {
+    warn: (msg: string) => void;
+}): boolean;
+/**
+ * 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>;
+
+/** 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 an `HttpRequestConfig` into an `HttpResourceRequest` by evaluating
+ * expression-based query params and (optionally) body values.
+ */
+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>;
+
+/** Generic reactive value — a static value, an Angular Signal, or an RxJS Observable. */
+type DynamicValue<T> = T | Signal<T> | Observable<T>;
+
+/** Universal addon slot names supported by every adapter. */
+type CommonAddonSlot = 'prefix' | 'suffix';
+/** Module-augmentable registry of adapter-specific addon slot names. */
+interface DynamicFormAddonSlotRegistry {
+}
+/**
+ * Union of every valid addon slot — universal slots plus any registered via
+ * {@link DynamicFormAddonSlotRegistry} module augmentation.
+ */
+type AddonSlot = CommonAddonSlot | keyof DynamicFormAddonSlotRegistry;
+
+/** Base shape every addon kind extends. */
+interface BaseAddon<TSlot extends AddonSlot = AddonSlot> {
+    /** Slot to render this addon in. */
+    readonly slot: TSlot;
+    /** CSS class applied to the addon host element. */
+    readonly className?: string;
+    /** Reactive visibility — when `true`, the addon is removed from layout. */
+    readonly hidden?: DynamicValue<boolean>;
+    /** Reactive disabled state — primarily relevant for interactive kinds. */
+    readonly disabled?: DynamicValue<boolean>;
+}
+/** Module-augmentable registry of addon kinds. */
+interface DynamicFormAddonRegistry {
+    text: TextAddon;
+    template: TemplateAddon;
+    component: ComponentAddon;
+}
+/** Union of every registered addon shape. */
+type AnyAddon = DynamicFormAddonRegistry[keyof DynamicFormAddonRegistry];
+/** Renders text content inline. */
+interface TextAddon extends BaseAddon {
+    readonly kind: 'text';
+    readonly text: DynamicText;
+}
+/** Renders a named `<ng-template>` projected into the host `<df-dynamic-form>`. */
+interface TemplateAddon extends BaseAddon {
+    readonly kind: 'template';
+    readonly templateKey: string;
+}
+/**
+ * Renders an arbitrary Angular component as the addon body.
+ *
+ * @codeOnly The `component` loader is a function and cannot survive
+ * `JSON.stringify`/`parse`. The lenient validator drops this kind when the
+ * config originated from JSON (set via `sanitizeFormConfig({ source: 'json' })`).
+ */
+interface ComponentAddon extends BaseAddon {
+    readonly kind: 'component';
+    readonly component: () => Promise<Type<unknown> | {
+        default: Type<unknown>;
+    }>;
+    readonly inputs?: Record<string, unknown>;
+}
+
+type WithInputSignals<T> = {
+    readonly [K in keyof T]-?: Signal<T[K]>;
+};
+
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+/** Resolves a wrapper type name to its registered config interface. */
+type WrapperConfig<TWrappers extends RegisteredWrapperTypes = RegisteredWrapperTypes> = TWrappers extends keyof FieldRegistryWrappers ? FieldRegistryWrappers[TWrappers] : {
+    readonly type: TWrappers;
+};
+/**
+ * Signature of a lazy component loader — either a direct component class or
+ * an ES module whose `default` export is the component. Shared by field and
+ * wrapper registrations so the `loadComponent: () => import('./x.component')`
+ * idiom types cleanly in both places.
+ */
+type LazyComponentLoader<T = unknown> = () => Promise<Type<T> | {
+    default: Type<T>;
+}>;
+/**
+ * Pre-computed reverse index used by `resolveWrappers`: field type → the
+ * wrappers that auto-apply to it. Built once in the `provideDynamicForm(...)`
+ * factory from every registered `WrapperTypeDefinition.types` entry.
+ */
+type WrapperAutoAssociations = ReadonlyMap<string, readonly WrapperConfig[]>;
+/** Configuration interface for registering wrapper types. */
+interface WrapperTypeDefinition<T extends WrapperConfig = WrapperConfig> {
+    /** Unique identifier for the wrapper type (also serves as discriminant from FieldTypeDefinition) */
+    wrapperName: string;
+    /** Wrapper definition type marker (internal use) */
+    _wrapper?: T;
+    /**
+     * Function to load the wrapper component (supports lazy loading).
+     * Returns a Promise that resolves to the component class or module with default export.
+     */
+    loadComponent: LazyComponentLoader;
+    /** Field types this wrapper should auto-apply to. */
+    types?: readonly string[];
+}
+/** Type guard for WrapperTypeDefinition. */
+declare function isWrapperTypeDefinition(value: unknown): value is WrapperTypeDefinition;
+/**
+ * Contract that wrapper components must satisfy.
+ *
+ * @Component({
+ *   template: `
+ *     <dbx-section [header]="header() ?? ''">
+ *       <ng-container #fieldComponent></ng-container>
+ *     </dbx-section>
+ *   `,
+ * })
+ * export class SectionWrapperComponent implements FieldWrapper {
+ *   readonly fieldComponent = viewChild.required('fieldComponent', { read: ViewContainerRef });
+ *   readonly header = input<string>();
+ *   readonly fieldInputs = input<WrapperFieldInputs>();
+ * }
+ * ```
+ */
+interface FieldWrapper {
+    /** ViewContainerRef slot where inner content is rendered */
+    readonly fieldComponent: Signal<ViewContainerRef>;
+}
+/** Injection token for the wrapper type registry. */
+declare const WRAPPER_REGISTRY: InjectionToken<Map<string, WrapperTypeDefinition<_ng_forge_dynamic_forms_internal.RowWrapper | _ng_forge_dynamic_forms_internal.CssWrapper>>>;
+/** Component cache for loaded wrapper components. */
+declare const WRAPPER_COMPONENT_CACHE: InjectionToken<Map<string, Type<unknown>>>;
+/**
+ * Pre-computed reverse index: `fieldType → WrapperConfig[]` for every
+ * registered `WrapperTypeDefinition.types` entry. Built once in the
+ * `provideDynamicForm(...)` factory so `resolveWrappers` can look up
+ * auto-associations in O(1) per field instead of scanning the full
+ * wrapper registry on every render.
+ */
+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;
+}
+
+/**
+ * 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>>>;
+
+/**
+ * Logic configuration for container fields (page, group, row, array).
+ * Containers only support the 'hidden' logic type since they are layout containers,
+ * not form controls (they can't be readonly, disabled, or required).
+ */
+interface ContainerLogicConfig {
+    /** Only 'hidden' is supported for container fields */
+    type: 'hidden';
+    /**
+     * Condition that determines when this container is hidden.
+     * Can be a boolean or a conditional expression evaluated against form values.
+     */
+    condition: ConditionalExpression | boolean;
+}
+
+/**
+ * Row field interface for creating horizontal layouts.
+ * A row is a synthetic field type that resolves to a Container at runtime,
+ * with a synthesized `{ type: 'row' }` wrapper applied for layout. The row
+ * itself does not hold a value — its children flatten into the parent form.
+ */
+interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowAllowedChildren[]> extends FieldDef<never> {
+    type: 'row';
+    /** Child definitions to render within this row */
+    readonly fields: TFields;
+    /** Row fields do not have a label property * */
+    readonly label?: never;
+    /** Rows do not support meta - they have no native form element * */
+    readonly meta?: never;
+    /**
+     * Logic configurations for conditional row visibility.
+     * Only 'hidden' type logic is supported for rows.
+     */
+    readonly logic?: ContainerLogicConfig[];
+}
+/** Type guard for RowField with proper type narrowing */
+declare function isRowField(field: FieldDef<any>): field is RowField;
+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
+ */
+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>>;
+
+/** Container field interface for wrapping child fields with UI chrome. */
+interface ContainerField<TFields extends readonly ContainerAllowedChildren[] = readonly ContainerAllowedChildren[], TWrapperConfigs extends readonly WrapperConfig[] = readonly WrapperConfig[]> extends FieldDef<never> {
+    type: 'container';
+    /** Child definitions to render within this container */
+    readonly fields: TFields;
+    /**
+     * Wrapper components to chain around the children.
+     * Applied outermost-first: the first wrapper in the array is the outermost.
+     * Each wrapper component receives the subsequent wrapper (or children) inside
+     * its `#fieldComponent` ViewContainerRef slot.
+     */
+    readonly wrappers: TWrapperConfigs;
+    /** Container fields do not have a label property */
+    readonly label?: never;
+    /** Containers do not support meta — they have no native form element */
+    readonly meta?: never;
+    /**
+     * Logic configurations for conditional container visibility.
+     * Only 'hidden' type logic is supported for containers.
+     */
+    readonly logic?: ContainerLogicConfig[];
+}
+/** Type guard for ContainerField with proper type narrowing. */
+declare function isContainerTypedField(field: FieldDef<any>): field is ContainerField;
+type ContainerComponent = FieldComponent<ContainerField<ContainerAllowedChildren[]>>;
+
+/**
+ * Type constraints for field nesting rules
+ * These ensure that container fields can only contain valid child field types
+ */
+/**
+ * Fields that are allowed as children of Page fields
+ * Pages can contain: rows, groups, arrays, and leaf fields (but NOT other pages)
+ */
+type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
+/**
+ * Fields that are allowed as children of Group fields
+ * Groups can contain: rows, arrays, and leaf fields (but NOT pages or other groups)
+ */
+type GroupAllowedChildren = LeafFieldTypes | RowField | ArrayField | SimplifiedArrayField | ContainerField;
+/**
+ * Fields that are allowed as children of Array fields
+ * Arrays can contain: rows, groups, and leaf fields (but NOT pages or other arrays)
+ * Groups are used for creating object arrays where each array item is an object
+ */
+type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField | ContainerField;
+/**
+ * Fields that are allowed as children of Container fields.
+ * Containers are pure layout primitives that flatten their children into the
+ * parent form, so most registered field types may appear inside — including
+ * hidden fields and other containers — but NOT pages.
+ */
+type ContainerAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField | ContainerField;
+/**
+ * Row is a synthetic field type that resolves to a Container at runtime, so
+ * it accepts the same children as a Container.
+ */
+type RowAllowedChildren = ContainerAllowedChildren;
+
+/**
+ * An array item template is an array of allowed children that defines one OBJECT array item's fields.
+ * Used for object arrays where each item is `{ key1: value1, key2: value2, ... }`.
+ */
+type ArrayItemTemplate = readonly ArrayAllowedChildren[];
+/**
+ * An array item definition can be either:
+ * - A single field (ArrayAllowedChildren) for PRIMITIVE array items - extracts field value directly
+ * - An array of fields (ArrayItemTemplate) for OBJECT array items - merges fields into object
+ */
+type ArrayItemDefinition = ArrayAllowedChildren | ArrayItemTemplate;
+/** Array field interface for creating dynamic field collections that map to array values. */
+interface ArrayField<TFields extends readonly ArrayItemDefinition[] = readonly ArrayItemDefinition[]> extends FieldDef<never> {
+    type: 'array';
+    /**
+     * Array of item definitions. Each element defines one array item:
+     * - Single FieldDef = primitive item (field's value is extracted directly)
+     * - Array of FieldDefs = object item (fields are merged into an object)
+     * - Empty array `[]` = no initial items (add via buttons with explicit templates)
+     * - Items can have different configurations (heterogeneous arrays supported)
+     * - Initial values are set via `value` property on each field definition
+     */
+    readonly fields: TFields;
+    /** Array fields do not have a label property * */
+    readonly label?: never;
+    /** Arrays do not support meta - they have no native form element * */
+    readonly meta?: never;
+    /**
+     * Logic configurations for conditional array visibility.
+     * Only 'hidden' type logic is supported for arrays.
+     */
+    readonly logic?: ContainerLogicConfig[];
+    /**
+     * Minimum number of items required in the array.
+     * Validation fails if the array has fewer items than this value.
+     */
+    readonly minLength?: number;
+    /**
+     * Maximum number of items allowed in the array.
+     * Validation fails if the array has more items than this value.
+     */
+    readonly maxLength?: number;
+}
+/**
+ * Type guard for ArrayField with proper type narrowing.
+ * Validates that the field is an array type with a fields property that is an array.
+ * Fields can contain either single FieldDefs (primitive items) or arrays of FieldDefs (object items).
+ */
+declare function isArrayField(field: FieldDef<any>): field is ArrayField;
+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;
+}
+/**
+ * Type guard for SimplifiedArrayField.
+ * Checks for `type: 'array'` with a `template` property (discriminant from full ArrayField).
+ */
+declare function isSimplifiedArrayField(field: FieldDef<any>): field is SimplifiedArrayField;
+
+/**
+ * Scalar types supported by hidden fields.
+ * These are the primitive value types that can be stored.
+ */
+type HiddenScalar = string | number | boolean;
+/**
+ * All value types supported by hidden fields.
+ * Supports both scalar values and arrays of scalars for storing
+ * multiple IDs or similar data.
+ */
+type HiddenValue = HiddenScalar | HiddenScalar[];
+/**
+ * Hidden field definition for storing values without rendering UI.
+ *
+ * @typeParam TValue - The type of value stored (must be HiddenValue compatible)
+ */
+interface HiddenField<TValue extends HiddenValue = HiddenValue> extends FieldDef<never> {
+    /** Discriminant for hidden field type */
+    type: 'hidden';
+    /**
+     * The value to store in the form.
+     * This is required - a hidden field without a value serves no purpose.
+     */
+    value: TValue;
+}
+/**
+ * Type guard to check if a field is a hidden field.
+ *
+ * @param field - The field to check
+ * @returns True if the field is a HiddenField
+ */
+declare function isHiddenField(field: FieldDef<unknown>): field is HiddenField;
+
+/**
+ * Page field interface for creating top-level page layouts
+ * This is a special field type that contains other field definitions
+ * The page itself doesn't have a value - it's a layout container like row
+ * Pages can only be used at the top level and cannot be nested
+ * This is a programmatic field type only - users cannot customize this field type
+ */
+interface PageField<TFields extends readonly PageAllowedChildren[] = PageAllowedChildren[]> extends FieldDef<never> {
+    type: 'page';
+    /** Child field definitions to render within this page */
+    readonly fields: TFields;
+    /** Page fields do not have a label property * */
+    readonly label?: never;
+    /** Pages do not support meta - they have no native form element * */
+    readonly meta?: never;
+    /**
+     * Logic configurations for conditional page visibility.
+     * Only 'hidden' type logic is supported for pages.
+     */
+    readonly logic?: ContainerLogicConfig[];
+}
+/** Type guard for PageField with proper type narrowing */
+declare function isPageField(field: FieldDef<unknown>): field is PageField;
+/**
+ * Validates that a page field doesn't contain nested page fields
+ *
+ * @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
+ */
+interface DynamicFormFieldRegistry {
+    /** Container fields that hold other fields (no value, have children) */
+    containers: FieldRegistryContainers;
+    /** Leaf fields that have values or display content */
+    leaves: FieldRegistryLeaves;
+    /** Field wrappers types */
+    wrappers: FieldRegistryWrappers;
+}
+/** Union type of all registered container field definitions */
+type ContainerFieldTypes = DynamicFormFieldRegistry['containers'][keyof DynamicFormFieldRegistry['containers']];
+/** Union type of all registered leaf field definitions */
+type LeafFieldTypes = DynamicFormFieldRegistry['leaves'][keyof DynamicFormFieldRegistry['leaves']];
+/** Union type of all registered field definitions */
+type RegisteredFieldTypes = ContainerFieldTypes | LeafFieldTypes;
+/** Extract field types that are available in the registry */
+type AvailableFieldTypes = keyof DynamicFormFieldRegistry['containers'] | keyof DynamicFormFieldRegistry['leaves'];
+/** Extract wrapper types that are available in the registry */
+type RegisteredWrapperTypes = keyof DynamicFormFieldRegistry['wrappers'];
+/**
+ * Combined registry mapping type names to field definitions.
+ * This flattens containers and leaves into a single mapping.
+ */
+type FieldTypeMap = DynamicFormFieldRegistry['containers'] & DynamicFormFieldRegistry['leaves'];
+/**
+ * Extract a specific field type from RegisteredFieldTypes based on the `type` discriminant.
+ * This enables proper type narrowing when defining fields.
+ */
+type ExtractField<T extends AvailableFieldTypes> = T extends keyof FieldTypeMap ? FieldTypeMap[T] : never;
+/**
+ * Narrow a field definition based on its `type` property.
+ * Use this to get proper type inference when working with field unions.
+ */
+type NarrowField<T> = T extends {
+    type: infer TType;
+} ? (TType extends AvailableFieldTypes ? ExtractField<TType> : T) : T;
+/**
+ * Narrow each field in an array based on its `type` property.
+ * Use with `satisfies` to get proper type inference for field arrays.
+ */
+type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
+
+/**
+ * Helper type to convert union to intersection.
+ * Uses `U extends U` to trigger distributive conditional type behavior.
+ */
+type UnionToIntersection<U> = (U extends U ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/** Depth counter for recursion limiting (prevents infinite type instantiation) */
+type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+/**
+ * Widens literal types to their primitive equivalents, recursively for objects and arrays.
+ * This prevents `as const` from over-narrowing types like `''` to literal `''` instead of `string`.
+ */
+type Widen<T, D extends number = 5> = [D] extends [never] ? T : T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer U)[] ? Widen<U, Depth[D]>[] : T extends Record<string, unknown> ? {
+    -readonly [K in keyof T]: Widen<T[K], Depth[D]>;
+} : T;
+/**
+ * Resolves the "underlying" non-null value type for a field, based on its `type`
+ * discriminator and (where it matters) its `value` literal. Used when we need a
+ * base type independent of whether the literal happens to be `null` — i.e., when
+ * computing the nullable widening for `value: null, nullable: true`.
+ */
+type ResolveBaseValueType<T, V> = T extends {
+    type: 'slider';
+} ? number : T extends {
+    type: 'input';
+    props: {
+        type: 'number';
+    };
+} ? number : T extends {
+    type: 'checkbox' | 'toggle';
+} ? boolean : [V] extends [null] ? string : Widen<V>;
+/**
+ * Infer value type based on field type, value literal, and the `nullable` flag.
+ * - Slider fields: always number
+ * - Input fields with props.type: 'number': number
+ * - Checkbox / toggle fields: always boolean
+ * - Other fields: widen the literal value type (default to string when value is null)
+ * - When `nullable: true` is declared, widens the result to `T | null`.
+ */
+type InferValueType<T, V> = T extends {
+    nullable: true;
+} ? ResolveBaseValueType<T, V> | null : ResolveBaseValueType<T, V>;
+/**
+ * Make type optional if field is not required.
+ * Hidden fields are never optional since they require a value property.
+ */
+type MaybeOptional<T, V> = T extends {
+    type: 'hidden';
+} ? V : T extends {
+    required: true;
+} ? V : V | undefined;
+/**
+ * Infers the value type from a single template field (for primitive arrays).
+ * Mirrors InferValueType logic: slider → number, input[number] → number,
+ * checkbox/toggle → boolean, else widen `value` (string fallback). Widens to
+ * `T | null` when `nullable: true` is declared on the template field.
+ */
+type InferSingleTemplateValueBase<T, D extends number> = T extends {
+    type: 'slider';
+} ? number : T extends {
+    type: 'input';
+    props: {
+        type: 'number';
+    };
+} ? number : T extends {
+    type: 'checkbox' | 'toggle';
+} ? boolean : T extends {
+    value: infer V;
+} ? [V] extends [null] ? string : Widen<V, Depth[D]> : string;
+type InferSingleTemplateValue<T, D extends number> = T extends {
+    nullable: true;
+} ? InferSingleTemplateValueBase<T, D> | null : InferSingleTemplateValueBase<T, D>;
+/**
+ * Infers the value type for an array field.
+ * Handles four cases:
+ * 1. Simplified array with template + value → infer item type from value
+ * 2. Simplified array with array template (no value) → infer object type from template fields
+ * 3. Simplified array with single-field template (no value) → infer primitive type from template field
+ * 4. Full-API array with fields → infer from children
+ */
+type InferArrayValue<T, D extends number> = T extends {
+    template: unknown;
+    value: readonly (infer Item)[];
+} ? Widen<Item>[] : T extends {
+    template: infer TArr;
+} ? TArr extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<[...TArr], Depth[D]>[] : InferSingleTemplateValue<TArr, D>[] : T extends {
+    fields: infer F;
+} ? F extends RegisteredFieldTypes[] ? InferFormValueWithDepth<F, Depth[D]>[] : unknown[] : unknown[];
+/** Process a single field and determine its contribution to the form value type */
+type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string, unknown> : T extends {
+    type: 'page' | 'row';
+    fields: infer F;
+} ? F extends RegisteredFieldTypes[] ? InferFormValueWithDepth<F, Depth[D]> : never : T extends {
+    type: 'group';
+    key: infer K;
+    fields: infer F;
+} ? K extends string ? F extends RegisteredFieldTypes[] ? {
+    [P in K]: InferFormValueWithDepth<F, Depth[D]>;
+} : {
+    [P in K]: Record<string, unknown>;
+} : never : T extends {
+    type: 'array';
+    key: infer K;
+} ? K extends string ? {
+    [P in K]: InferArrayValue<T, D>;
+} : never : T extends {
+    type: 'text';
+} ? never : T extends {
+    type: 'submit' | 'button' | 'next' | 'previous' | 'addArrayItem' | 'removeArrayItem';
+} ? never : T extends {
+    key: infer K;
+    value: infer V;
+} ? K extends string ? {
+    [P in K]: MaybeOptional<T, InferValueType<T, V>>;
+} : never : T extends {
+    key: infer K;
+} ? K extends string ? {
+    [P in K]: MaybeOptional<T, T extends {
+        nullable: true;
+    } ? string | null : string>;
+} : never : never;
+/** Internal helper with depth tracking */
+type InferFormValueWithDepth<T extends RegisteredFieldTypes[], D extends number = 5> = UnionToIntersection<ProcessField<T[number], D>>;
+/** Helper to extract fields from either fields array or FormConfig */
+type ExtractFields<T> = T extends {
+    fields: infer TFields;
+} ? TFields extends readonly RegisteredFieldTypes[] ? TFields : never : T extends readonly RegisteredFieldTypes[] ? T : never;
+/**
+ * Infer form value type from fields array or FormConfig.
+ * Recursively processes nested structures and merges the results.
+ * Limited to 5 levels of nesting to prevent infinite type instantiation.
+ */
+type InferFormValue<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<ExtractFields<T> extends RegisteredFieldTypes[] ? ExtractFields<T> : [...ExtractFields<T>], 5> : never;
+
+/**
+ * Re-export Angular's ValidationError for consistency
+ * This replaces our custom ValidationError interface
+ */
+type ValidationError = ValidationError$1;
+interface ValidationMessages {
+    required?: DynamicText;
+    email?: DynamicText;
+    min?: DynamicText;
+    max?: DynamicText;
+    minLength?: DynamicText;
+    maxLength?: DynamicText;
+    pattern?: DynamicText;
+    [key: string]: DynamicText | undefined;
+}
+
+/**
+ * The result type for submission actions.
+ * Can be either a Promise or an Observable.
+ */
+type SubmissionActionResult = Promise<TreeValidationResult> | Observable<TreeValidationResult | unknown>;
+/**
+ * Configuration for form submission handling.
+ *
+ * @typeParam TValue - The form value type
+ */
+interface SubmissionConfig<TValue = unknown> {
+    /**
+     * Action called when the form is submitted.
+     *
+     * @param form - The form's FieldTree instance
+     * @returns Promise or Observable - for errors, return TreeValidationResult
+     */
+    action: (form: FieldTree<TValue>) => SubmissionActionResult;
+}
+
+/**
+ * Configuration interface for defining dynamic form structure and behavior.
+ *
+ * @typeParam TFields - Array of registered field types available for this form
+ * @typeParam TValue - The strongly-typed interface for form values
+ * @typeParam TProps - The type for form-level default props (library-specific)
+ */
+interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, TProps extends object = Record<string, unknown>, TSchemaValue = unknown> {
+    /** Array of field definitions that define the form structure. */
+    fields: TFields;
+    /** Optional form-level validation schema using Standard Schema spec. */
+    schema?: FormSchema<TSchemaValue>;
+    /**
+     * Global form configuration options.
+     *
+     * @value {}
+     */
+    options?: FormOptions;
+    /** Global schemas available to all fields. */
+    schemas?: SchemaDefinition[];
+    /** Form-level validation messages that act as fallback for field-level messages. */
+    defaultValidationMessages?: ValidationMessages;
+    /** Signal forms adapter configuration. */
+    customFnConfig?: CustomFnConfig<TValue extends Record<string, unknown> ? TValue : Record<string, unknown>>;
+    /** Form submission configuration. */
+    submission?: SubmissionConfig<TValue>;
+    /** Default props applied to all fields in the form. */
+    defaultProps?: TProps;
+    /** External data signals available to conditional logic and derivations. */
+    externalData?: Record<string, Signal<unknown>>;
+    /** Form-wide default wrappers applied to every field that does not explicitly opt out. */
+    defaultWrappers?: readonly WrapperConfig[];
+}
+/** Signal forms adapter configuration for advanced form behavior. */
+interface CustomFnConfig<TFormValue extends Record<string, unknown> = Record<string, unknown>> {
+    /** Custom evaluation functions for conditional expressions. */
+    customFunctions?: Record<string, CustomFunction<TFormValue>>;
+    /** Custom derivation functions for value derivation logic. */
+    derivations?: Record<string, CustomFunction<TFormValue>>;
+    /** Async derivation functions for asynchronous value derivation logic. */
+    asyncDerivations?: Record<string, AsyncDerivationFunction<TFormValue>>;
+    /** Async condition functions for asynchronous field state logic. */
+    asyncConditions?: Record<string, AsyncConditionFunction<TFormValue>>;
+    /** Custom validators using Angular's public FieldContext API */
+    validators?: Record<string, CustomValidator>;
+    /** Async custom validators using Angular's resource-based validateAsync() API */
+    asyncValidators?: Record<string, AsyncCustomValidator>;
+    /** HTTP validators using Angular's validateHttp() API. */
+    httpValidators?: Record<string, HttpCustomValidator>;
+}
+/** Global form configuration options. */
+interface FormOptions {
+    /**
+     * Disable the entire form.
+     *
+     * @value false
+     */
+    disabled?: boolean;
+    /**
+     * Prefix scoping every field's DOM `id` (and matching `for` / `data-testid` /
+     * `aria-describedby`) to this form instance, as the outermost id segment:
+     * `{idPrefix}_{group}_{key}_{index}`. Use it when rendering multiple forms
+     * from the same config on one page so their ids don't collide.
+     *
+     * When omitted, a lone form stays unprefixed and a generated prefix (`df-1`,
+     * `df-2`, …) is applied automatically once a second form is mounted. Characters
+     * invalid in an id token (whitespace, punctuation) are replaced with `_`.
+     *
+     * @example
+     * ```typescript
+     * options: { idPrefix: 'billing' } // → id="billing_email-input"
+     * ```
+     *
+     * @default undefined (auto-prefix only when multiple forms are mounted)
+     */
+    idPrefix?: string;
+    /**
+     * Maximum number of iterations for derivation chain processing.
+     *
+     * @default 10
+     */
+    maxDerivationIterations?: number;
+    /** Default disabled behavior for submit buttons. */
+    submitButton?: SubmitButtonOptions;
+    /** Default disabled behavior for next page buttons. */
+    nextButton?: NextButtonOptions;
+    /**
+     * Whether to exclude values of hidden fields from submission output.
+     *
+     * @default undefined (uses global setting)
+     */
+    excludeValueIfHidden?: boolean;
+    /**
+     * Whether to exclude values of disabled fields from submission output.
+     *
+     * @default undefined (uses global setting)
+     */
+    excludeValueIfDisabled?: boolean;
+    /**
+     * Whether to exclude values of readonly fields from submission output.
+     *
+     * @default undefined (uses global setting)
+     */
+    excludeValueIfReadonly?: boolean;
+    /**
+     * Whether to run validation when a field is hidden.
+     *
+     * @default undefined (uses global setting, which defaults to `false`)
+     */
+    validateWhenHidden?: boolean;
+    /**
+     * Whether to attach the current form value to all events dispatched through the EventBus.
+     *
+     * @default undefined (uses global setting)
+     */
+    emitFormValueOnEvents?: boolean;
+}
+/** Options for controlling submit button disabled behavior. */
+interface SubmitButtonOptions {
+    /**
+     * Disable submit button when the form is invalid.
+     *
+     * @default true
+     */
+    disableWhenInvalid?: boolean;
+    /**
+     * Disable submit button while the form is submitting.
+     *
+     * @default true
+     */
+    disableWhileSubmitting?: boolean;
+}
+/** Options for controlling next page button disabled behavior. */
+interface NextButtonOptions {
+    /**
+     * Disable next button when the current page has invalid fields.
+     *
+     * @default true
+     */
+    disableWhenPageInvalid?: boolean;
+    /**
+     * Disable next button while the form is submitting.
+     *
+     * @default true
+     */
+    disableWhileSubmitting?: boolean;
+}
+
+/** Context for resolving button disabled state. */
+interface ButtonLogicContext {
+    /** The form's FieldTree instance (supports both string and number keys for array indices) */
+    form: FieldTree<unknown, string | number>;
+    /** Form-level options */
+    formOptions?: FormOptions;
+    /** Field-level logic array (if provided) */
+    fieldLogic?: LogicConfig[];
+    /** Explicit disabled state from field definition */
+    explicitlyDisabled?: boolean;
+    /** Current page validity signal (for paged forms) */
+    currentPageValid?: Signal<boolean>;
+    /** Current form value for evaluating conditional expressions */
+    formValue?: unknown;
+    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
+    logger?: Logger;
+}
+/**
+ * Allowed logic types for non-form-bound elements (buttons, text fields, etc.).
+ * These elements only support hidden and disabled states - not readonly or required
+ * since they don't participate in form validation.
+ */
+type NonFieldLogicType = 'hidden' | 'disabled';
+/**
+ * Logic config restricted to types valid for non-form-bound elements.
+ * This is a subset of LogicConfig that only includes hidden and disabled types.
+ */
+type NonFieldLogicConfig = LogicConfig & {
+    type: NonFieldLogicType;
+};
+/** Context for resolving state (hidden/disabled) for non-form-bound elements. */
+interface NonFieldLogicContext {
+    /** The form's FieldTree instance (supports both string and number keys for array indices) */
+    form: FieldTree<unknown, string | number>;
+    /**
+     * Field-level logic array containing conditions.
+     * Accepts full LogicConfig[] for compatibility, but only hidden and disabled types are processed.
+     */
+    fieldLogic?: LogicConfig[];
+    /** Explicit state from field definition (e.g., `hidden: true` or `disabled: true`) */
+    explicitValue?: boolean;
+    /** Current form value for evaluating conditional expressions */
+    formValue?: unknown;
+    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
+    logger?: Logger;
+}
+/**
+ * Resolves the disabled state for a submit button.
+ *
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
+ */
+declare function resolveSubmitButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+/**
+ * Resolves the disabled state for a next page button.
+ *
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
+ */
+declare function resolveNextButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+/**
+ * Evaluates the hidden state for non-form-bound elements synchronously.
+ *
+ * @param ctx - The context containing form, logic array, and explicit hidden state
+ * @returns true when the element should be hidden
+ */
+declare function evaluateNonFieldHidden(ctx: NonFieldLogicContext): boolean;
+/**
+ * Resolves the hidden state for non-form-bound elements as a reactive signal.
+ *
+ * @param ctx - The context containing form, logic array, and explicit hidden state
+ * @returns A computed signal that returns true when the element should be hidden
+ */
+declare function resolveNonFieldHidden(ctx: NonFieldLogicContext): Signal<boolean>;
+/**
+ * Evaluates the disabled state for non-form-bound elements synchronously.
+ *
+ * @param ctx - The context containing form, logic array, and explicit disabled state
+ * @returns true when the element should be disabled
+ */
+declare function evaluateNonFieldDisabled(ctx: NonFieldLogicContext): boolean;
+/**
+ * Resolves the disabled state for non-form-bound elements as a reactive signal.
+ *
+ * @param ctx - The context containing form, logic array, and explicit disabled state
+ * @returns A computed signal that returns true when the element should be disabled
+ */
+declare function resolveNonFieldDisabled(ctx: NonFieldLogicContext): Signal<boolean>;
+
+/**
+ * Service that provides field evaluation context by combining
+ * field context with root form registry information.
+ */
+declare class FieldContextRegistryService {
+    private rootFormRegistry;
+    private logger;
+    private deprecationTracker;
+    private externalDataSignal;
+    /**
+     * Creates an evaluation context for a field by combining:
+     * - The field's current value
+     * - The root form value from the registry
+     * - The field path (if available from form context)
+     * - Custom functions (if provided)
+     */
+    createEvaluationContext<TValue>(fieldContext: FieldContext<TValue>, customFunctions?: Record<string, (context: EvaluationContext) => unknown>): EvaluationContext;
+    /** Extracts the field path (key) for a given field context. */
+    private extractFieldPath;
+    /** Builds an evaluation context scoped to a specific array item. */
+    private buildArrayScopedContext;
+    /**
+     * Resolves external data signals to their current values.
+     *
+     * @param reactive - If true, reads signals reactively (creates dependencies).
+     *                   If false, reads signals with untracked() (no dependencies).
+     * @returns Record of resolved external data values, or undefined if no external data.
+     */
+    private resolveExternalData;
+    /** Creates a REACTIVE evaluation context for logic functions. */
+    createReactiveEvaluationContext<TValue>(fieldContext: FieldContext<TValue>, customFunctions?: Record<string, (context: EvaluationContext) => unknown>): EvaluationContext;
+    /**
+     * Creates an evaluation context for display-only components (text fields, pages)
+     * that don't have their own FieldContext.
+     *
+     * @param fieldPath - The key/path of the display-only component
+     * @param customFunctions - Optional custom functions for expression evaluation
+     */
+    createDisplayOnlyContext(fieldPath: string, customFunctions?: Record<string, (context: EvaluationContext) => unknown>): EvaluationContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldContextRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FieldContextRegistryService>;
+}
+
+/** Registry service for custom functions and validators */
+declare class FunctionRegistryService {
+    private readonly customFunctions;
+    private readonly customFunctionScopes;
+    private readonly derivationFunctions;
+    private readonly asyncDerivationFunctions;
+    private readonly asyncConditionFunctions;
+    private readonly validators;
+    private readonly asyncValidators;
+    private readonly httpValidators;
+    /**
+     * Register a custom function for conditional expressions
+     *
+     * @param name - Unique identifier for the function
+     * @param fn - Function that receives EvaluationContext and returns any value
+     * @param options - Optional configuration for the function
+     */
+    registerCustomFunction(name: string, fn: CustomFunction, options?: CustomFunctionOptions): void;
+    /**
+     * Get the scope of a registered custom function.
+     *
+     * @param name - The function name
+     * @returns The function scope, or undefined if not registered
+     */
+    getCustomFunctionScope(name: string): CustomFunctionScope | undefined;
+    /**
+     * Check if a custom function is field-scoped (no cross-field dependencies).
+     *
+     * @param name - The function name
+     * @returns true if the function is field-scoped, false if form-scoped or not registered
+     */
+    isFieldScopedFunction(name: string): boolean;
+    /** Get all custom functions as an object */
+    getCustomFunctions(): Record<string, CustomFunction>;
+    /** Clear all custom functions and their scopes */
+    clearCustomFunctions(): void;
+    /**
+     * Register a derivation function for value derivation logic.
+     *
+     * @param name - Unique identifier for the function
+     * @param fn - Function that receives EvaluationContext and returns the derived value
+     */
+    registerDerivationFunction(name: string, fn: CustomFunction): void;
+    /** Get a derivation function by name */
+    getDerivationFunction(name: string): CustomFunction | undefined;
+    /** Get all derivation functions as an object */
+    getDerivationFunctions(): Record<string, CustomFunction>;
+    /**
+     * Set derivation functions from a config object.
+     * Only updates functions if their references have changed.
+     *
+     * @param derivations - Object mapping function names to derivation functions
+     */
+    setDerivationFunctions(derivations: Record<string, CustomFunction> | undefined): void;
+    /** Clear all derivation functions */
+    clearDerivationFunctions(): void;
+    /**
+     * Register an async derivation function.
+     *
+     * @param name - Unique identifier for the function
+     * @param fn - Function that receives EvaluationContext and returns Promise/Observable
+     */
+    registerAsyncDerivationFunction(name: string, fn: AsyncDerivationFunction): void;
+    /** Get an async derivation function by name */
+    getAsyncDerivationFunction(name: string): AsyncDerivationFunction | undefined;
+    /** Get all async derivation functions as an object */
+    getAsyncDerivationFunctions(): Record<string, AsyncDerivationFunction>;
+    /**
+     * Set async derivation functions from a config object.
+     * Only updates functions if their references have changed.
+     *
+     * @param fns - Object mapping function names to async derivation functions
+     */
+    setAsyncDerivationFunctions(fns: Record<string, AsyncDerivationFunction> | undefined): void;
+    /** Clear all async derivation functions */
+    clearAsyncDerivationFunctions(): void;
+    /**
+     * Register an async condition function.
+     *
+     * @param name - Unique identifier for the function
+     * @param fn - Function that receives EvaluationContext and returns Promise/Observable of boolean
+     */
+    registerAsyncConditionFunction(name: string, fn: AsyncConditionFunction): void;
+    /** Get an async condition function by name */
+    getAsyncConditionFunction(name: string): AsyncConditionFunction | undefined;
+    /** Get all async condition functions as an object */
+    getAsyncConditionFunctions(): Record<string, AsyncConditionFunction>;
+    /**
+     * Set async condition functions from a config object.
+     * Only updates functions if their references have changed.
+     *
+     * @param fns - Object mapping function names to async condition functions
+     */
+    setAsyncConditionFunctions(fns: Record<string, AsyncConditionFunction> | undefined): void;
+    /** Clear all async condition functions */
+    clearAsyncConditionFunctions(): void;
+    /**
+     * Register a custom validator using Angular's public FieldContext API
+     *
+     * @param name - Unique identifier for the validator
+     * @param fn - Validator function (ctx, params?) => ValidationError | ValidationError[] | null
+     */
+    registerValidator(name: string, fn: CustomValidator): void;
+    /** Get a validator by name */
+    getValidator(name: string): CustomValidator | undefined;
+    /** Clear all validators */
+    clearValidators(): void;
+    /**
+     * Register an async validator using Angular's public validateAsync() API
+     *
+     * @param name - Unique identifier for the async validator
+     * @param fn - Async validator function (ctx, params?) => Observable<ValidationError | ValidationError[] | null>
+     */
+    registerAsyncValidator(name: string, fn: AsyncCustomValidator): void;
+    /** Get an async validator by name */
+    getAsyncValidator(name: string): AsyncCustomValidator | undefined;
+    /** Clear all async validators */
+    clearAsyncValidators(): void;
+    /**
+     * Register an HTTP validator configuration using Angular's public validateHttp() API
+     *
+     * @param name - Unique identifier for the HTTP validator
+     * @param config - HTTP validator configuration object
+     */
+    registerHttpValidator(name: string, config: HttpCustomValidator): void;
+    /** Get an HTTP validator by name */
+    getHttpValidator(name: string): HttpCustomValidator | undefined;
+    /** Clear all HTTP validators */
+    clearHttpValidators(): void;
+    /**
+     * Generic helper to set registry values only if they have changed
+     *
+     * @param registry - The Map to update
+     * @param values - Object mapping keys to values
+     */
+    private setRegistryIfChanged;
+    /**
+     * Set validators from a config object
+     * Only updates validators if their references have changed
+     *
+     * @param validators - Object mapping validator names to validator functions
+     */
+    setValidators(validators: Record<string, CustomValidator> | undefined): void;
+    /**
+     * Set async validators from a config object
+     * Only updates validators if their references have changed
+     *
+     * @param asyncValidators - Object mapping validator names to async validator configs
+     */
+    setAsyncValidators(asyncValidators: Record<string, AsyncCustomValidator> | undefined): void;
+    /**
+     * Set HTTP validators from a config object
+     * Only updates validators if their references have changed
+     *
+     * @param httpValidators - Object mapping validator names to HTTP validator configs
+     */
+    setHttpValidators(httpValidators: Record<string, HttpCustomValidator> | undefined): void;
+    /** Clear everything (functions and all validators) */
+    clearAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FunctionRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FunctionRegistryService>;
+}
+
+/** Registry service that provides access to the root form and its values. */
+declare class RootFormRegistryService {
+    readonly formValue: Signal<Record<string, unknown>>;
+    readonly rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>;
+    constructor(formValue: Signal<Record<string, unknown>>, rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>);
+}
+
+declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
+declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
+
+/**
+ * Create a dynamic value function from an expression string.
+ * Uses secure AST-based parsing.
+ *
+ * @param expression The expression string to evaluate
+ * @returns A LogicFn that evaluates the expression in the context of a field
+ */
+declare function createDynamicValueFunction<TValue, TReturn>(expression: string): LogicFn<TValue, TReturn>;
+
+/** DI-scoped cache for dynamic value functions. */
+declare class DynamicValueFunctionCacheService {
+    /** Cache for memoized dynamic value functions, keyed by expression string. */
+    readonly dynamicValueFunctionCache: Map<string, LogicFn<unknown, unknown>>;
+}
+
+interface FieldWithValidation {
+    readonly required?: boolean;
+    readonly email?: boolean;
+    readonly min?: number;
+    readonly max?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string | RegExp;
+    readonly validators?: ValidatorConfig[];
+    readonly validationMessages?: ValidationMessages;
+    readonly logic?: LogicConfig[];
+    /** Shorthand for simple computed/derived fields. */
+    readonly derivation?: string;
+    readonly schemas?: SchemaApplicationConfig[];
+}
+
+interface BaseCheckedField<TProps, TMeta extends FieldMeta = FieldMeta, TNullable extends boolean = false> extends FieldDef<TProps, TMeta>, FieldWithValidation {
+    value?: TNullable extends true ? boolean | null : boolean;
+    /**
+     * Placeholder text displayed when the field is empty.
+     * Supports static strings, Observables, and Signals for dynamic content.
+     */
+    placeholder?: DynamicText;
+    required?: boolean;
+    /**
+     * Whether the field accepts `null` as a valid value.
+     *
+     * @default false
+     */
+    nullable?: TNullable;
+}
+declare function isCheckedField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseCheckedField<TProps, TMeta, boolean>;
+type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons';
+type CheckedFieldComponent<T extends BaseCheckedField<Record<string, unknown> | unknown, FieldMeta, boolean>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
+
+/**
+ * Supported primitive value types for form fields.
+ * This type represents all possible value types that can be used in form fields.
+ */
+type ValueType = string | number | boolean | Date | object | unknown[];
+interface BaseValueField<TProps, TValue, TMeta extends FieldMeta = FieldMeta, TNullable extends boolean = false> extends FieldDef<TProps, TMeta>, FieldWithValidation {
+    value?: TNullable extends true ? TValue | null : TValue;
+    /**
+     * Placeholder text displayed when the field is empty.
+     * Supports static strings, Observables, and Signals for dynamic content.
+     */
+    placeholder?: DynamicText;
+    required?: boolean;
+    /**
+     * Whether the field accepts `null` as a valid value.
+     *
+     * @default false
+     */
+    nullable?: TNullable;
+}
+declare function isValueField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseValueField<TProps, ValueType, TMeta, boolean>;
+type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'valueType' | 'nullable' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'derivation' | 'schemas' | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly' | 'validateWhenHidden' | 'wrappers' | 'skipAutoWrappers' | 'skipDefaultWrappers' | 'addons';
+type ValueFieldComponent<T extends BaseValueField<Record<string, unknown> | unknown, unknown, FieldMeta, boolean>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
+
+/** Base interface for all form events in the dynamic form system. */
+interface FormEvent {
+    /** Unique identifier for the event type used for filtering and subscriptions */
+    readonly type: string;
+    /**
+     * Optional form value attached to the event when `withEventFormValue()` is enabled
+     * or `options.emitFormValueOnEvents` is set to `true` in the form config.
+     */
+    readonly formValue?: unknown;
+}
+/**
+ * Type guard to check if a form event has a form value attached.
+ *
+ * @param event - The form event to check
+ * @returns `true` if the event has a form value attached, narrowing the type
+ */
+declare function hasFormValue<T extends FormEvent>(event: T): event is T & {
+    formValue: unknown;
+};
+/**
+ * Constructor type for form event classes.
+ *
+ * @typeParam T - The form event type being constructed
+ */
+type FormEventConstructor<T extends FormEvent = FormEvent> = new (...args: any[]) => T;
+
+declare class ComponentInitializedEvent implements FormEvent {
+    componentType: 'dynamic-form' | 'page' | 'group' | 'array' | 'container';
+    componentId: string;
+    readonly type: "component-initialized";
+    constructor(componentType: 'dynamic-form' | 'page' | 'group' | 'array' | 'container', componentId: string);
+}
+
+declare class EventBus {
+    private readonly pipeline$;
+    private readonly globalEmitFormValue;
+    private readonly rootFormRegistry;
+    private readonly formOptions;
+    private readonly logger;
+    events$: Observable<FormEvent>;
+    /**
+     * Dispatches a pre-created event instance directly.
+     *
+     * @param event - A FormEvent instance to dispatch
+     */
+    dispatch(event: FormEvent): void;
+    /**
+     * Dispatches an event to all subscribers by instantiating the provided constructor.
+     *
+     * @param eventConstructor - Constructor function for the event to dispatch
+     * @param args - Arguments to pass to the event constructor
+     */
+    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
+    /**
+     * Dispatches a pre-created event instance directly.
+     * Used internally by EventDispatcher to forward events into the bus.
+     *
+     * @internal
+     */
+    emitInstance(event: FormEvent): void;
+    /**
+     * Shared emit path for both dispatch() and emitInstance().
+     * Attaches form value if configured, then pushes to the pipeline.
+     */
+    private emit;
+    /**
+     * Emits an event through the pipeline. Catches any synchronous exception that escapes
+     * RxJS's own error handling so dispatch() callers are never disrupted by a failing subscriber.
+     */
+    private safeEmit;
+    /** Determines whether form value should be attached to events. */
+    private shouldEmitFormValue;
+    /**
+     * Subscribes to events of a specific type.
+     *
+     * @param eventType - The type of event to subscribe to
+     * @returns Observable that emits events of the specified type
+     */
+    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
+    /**
+     * Subscribes to events of multiple types.
+     *
+     * @param eventType - Array of event types to subscribe to
+     * @returns Observable that emits events matching any of the specified types
+     */
+    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventBus, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventBus>;
+}
+
+/** Context for token resolution in event args */
+interface TokenContext {
+    /** Current field key */
+    key?: string;
+    /** Array index if field is inside an array */
+    index?: number;
+    /** Parent array field key if field is inside an array */
+    arrayKey?: string;
+    /** Current form value for complex indexing */
+    formValue?: unknown;
+    /** Template for array item creation */
+    template?: unknown;
+}
+/**
+ * Resolves special tokens in event arguments to their actual values
+ *
+ * @param args - Array of arguments that may contain tokens
+ * @param context - Context object containing token values
+ * @returns Array with resolved values
+ */
+declare function resolveTokens(args: readonly (string | number | boolean | null | undefined)[], context: TokenContext): (string | number | boolean | null | undefined | unknown)[];
+
+interface FieldWithHiddenLogic {
+    hidden?: boolean;
+    logic?: readonly (ContainerLogicConfig | LogicConfig)[];
+}
+/**
+ * Applies hidden logic to a mapper's input record.
+ *
+ * @param inputs The mutable input record to potentially add `hidden` to
+ * @param fieldDef The field definition containing `hidden` and `logic`
+ * @param rootFormRegistry The root form registry for accessing form state
+ */
+declare function applyHiddenLogic(inputs: Record<string, unknown>, fieldDef: FieldWithHiddenLogic, rootFormRegistry: RootFormRegistryService): void;
+
+/**
+ * Maps an array field definition to component inputs.
+ *
+ * @param fieldDef The array field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function arrayFieldMapper(fieldDef: ArrayField): Signal<Record<string, unknown>>;
+
+/**
+ * Builds base input properties from a field definition.
+ *
+ * @param fieldDef The field definition to extract properties from
+ * @param defaultProps Optional form-level default props to merge with field props
+ * @returns Record of input names to values
+ */
+declare function buildBaseInputs(fieldDef: FieldDef<unknown>, defaultProps?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Base field mapper that extracts common field properties into component inputs.
+ *
+ * @param fieldDef The field definition to map
+ * @returns Signal containing Record of input names to values
+ */
+declare function baseFieldMapper(fieldDef: FieldDef<unknown>): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a container field definition to component inputs.
+ *
+ * @param fieldDef The container field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function containerFieldMapper(fieldDef: ContainerField): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a group field definition to component inputs.
+ *
+ * @param fieldDef The group field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function groupFieldMapper(fieldDef: GroupField): Signal<Record<string, unknown>>;
+
+/**
+ * Field signal context - the "nervous system" of the dynamic form.
+ * Provided via FIELD_SIGNAL_CONTEXT injection token.
+ */
+interface FieldSignalContext<TModel extends Record<string, unknown> = Record<string, unknown>> {
+    injector: Injector;
+    value: WritableSignal<Partial<TModel> | undefined>;
+    defaultValues: () => TModel;
+    form: FieldTree<TModel>;
+    /** Current page validity signal for paged forms. Used by next button to determine disabled state. */
+    currentPageValid?: Signal<boolean>;
+}
+/**
+ * Array context for fields rendered within arrays.
+ * Provides position and parent array information for components inside array fields.
+ */
+interface ArrayContext {
+    /** The key of the parent array field. */
+    arrayKey: string;
+    /**
+     * The index of this item within the array.
+     * Uses linkedSignal to automatically update when items are added/removed,
+     * allowing index-dependent logic to react without component recreation.
+     */
+    index: Signal<number>;
+    /** The current form value for token resolution. */
+    formValue: unknown;
+    /** The array field definition. */
+    field: FieldDef<unknown>;
+}
+/** Group context for fields rendered inside `group` containers. */
+interface GroupContext {
+    /** Dot-separated path of group ancestors, including the current group's key (e.g. `'address'` or `'user.address'`). */
+    groupPath: Signal<string>;
+}
+/** Mapper function that converts a field definition to component inputs. */
+type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string, unknown>>;
+
+/** Maps a row field definition to container component inputs. */
+declare function rowFieldMapper(fieldDef: RowField): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a page field definition to component inputs.
+ *
+ * @param fieldDef The page field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function pageFieldMapper(fieldDef: PageField): Signal<Record<string, unknown>>;
+
+/**
+ * Maps a text field definition to component inputs.
+ *
+ * @param fieldDef The text field definition
+ * @returns Signal containing Record of input names to values for ngComponentOutlet
+ */
+declare function textFieldMapper(fieldDef: TextField): Signal<Record<string, unknown>>;
+
+/**
+ * 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.
+ */
+interface AddonKindSchema {
+    readonly $ref?: string;
+    readonly $schema?: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly type?: 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null' | ReadonlyArray<'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null'>;
+    readonly enum?: ReadonlyArray<unknown>;
+    readonly const?: unknown;
+    readonly properties?: Readonly<Record<string, AddonKindSchema>>;
+    readonly required?: ReadonlyArray<string>;
+    readonly additionalProperties?: boolean | AddonKindSchema;
+    readonly items?: AddonKindSchema | ReadonlyArray<AddonKindSchema>;
+    readonly oneOf?: ReadonlyArray<AddonKindSchema>;
+    readonly anyOf?: ReadonlyArray<AddonKindSchema>;
+    readonly allOf?: ReadonlyArray<AddonKindSchema>;
+    readonly not?: AddonKindSchema;
+    readonly default?: unknown;
+    readonly examples?: ReadonlyArray<unknown>;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly format?: string;
+    /** Vendor extensions and unrecognised keywords pass through untyped. */
+    readonly [key: string]: unknown;
+}
+/**
+ * Optional shape validator a kind ships to enforce its required fields at
+ * runtime. Throws are caught by the validator and converted into lenient
+ * warnings; the offending addon is dropped and the form keeps rendering.
+ */
+type AddonShapeValidator<T extends BaseAddon = BaseAddon> = (addon: T, fieldKey: string) => void;
+/** Per-kind registration metadata. */
+interface AddonKindDefinition<T extends BaseAddon = BaseAddon> {
+    /** Discriminant matching `addon.kind`. */
+    readonly kind: string;
+    /** Lazy loader for the kind's renderer component. */
+    readonly loadComponent: LazyComponentLoader;
+    /** Optional shape validator — throw `DynamicFormError` to drop the addon with a warning. */
+    readonly validate?: AddonShapeValidator<T>;
+    /** Optional JSON Schema fragment for MCP / pre-flight tooling. */
+    readonly schema?: AddonKindSchema;
+    /**
+     * Whether the kind survives `JSON.stringify` / `JSON.parse`. Kinds whose
+     * shape includes a function payload (e.g., the built-in `'component'`
+     * loader, inline `prime-button` `action` handlers) declare `jsonSafe: false`
+     * so the validator drops them when the config was loaded from a JSON
+     * source (`sanitizeFormConfig(config, { source: 'json' })`). Defaults to
+     * `true` — kinds are JSON-safe unless explicitly opted out.
+     */
+    readonly jsonSafe?: boolean;
+}
+/** Per-field-type addon-support metadata declared at field registration. */
+interface FieldAddonSupport {
+    /** Slots a field of this type accepts. */
+    readonly slots: readonly AddonSlot[];
+    /** Optional whitelist of allowed addon kinds. Omitted = any registered kind. */
+    readonly allowedKinds?: readonly string[];
+}
+/** Global registry of addon kinds. */
+declare const ADDON_KIND_REGISTRY: InjectionToken<Map<string, AddonKindDefinition<BaseAddon<AddonSlot>>>>;
+
+/**
+ * Map of named `TemplateRef`s collected by `<df-dynamic-form>` from
+ * `<ng-template dfTemplate="...">` children projected into its content.
+ * The directive selector is `dfTemplate` (see `DfTemplate`); the input
+ * value is the name addons reference via `templateKey`.
+ */
+declare const DF_FIELD_TEMPLATES: InjectionToken<Signal<ReadonlyMap<string, TemplateRef<unknown>>>>;
+
+interface FieldOption<T = unknown> {
+    label: DynamicText;
+    value: T;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+
+/** Injection token for form-level default wrappers. */
+declare const DEFAULT_WRAPPERS: InjectionToken<Signal<readonly WrapperConfig[] | undefined>>;
+/** Injection token for providing field signal context to mappers and components. */
+declare const FIELD_SIGNAL_CONTEXT: InjectionToken<FieldSignalContext<Record<string, unknown>>>;
+/** Throwing accessor for {@link FIELD_SIGNAL_CONTEXT}. */
+declare function injectFieldSignalContext<TModel extends Record<string, unknown> = Record<string, unknown>>(): FieldSignalContext<TModel>;
+/** Injection token for providing array context metadata to mappers and components. */
+declare const ARRAY_CONTEXT: InjectionToken<ArrayContext>;
+/** Injection token for providing group ancestry to mappers and components. */
+declare const GROUP_CONTEXT: InjectionToken<GroupContext>;
+/** Injection token for form-level default props. */
+declare const DEFAULT_PROPS: InjectionToken<Signal<Record<string, unknown> | undefined>>;
+/** Injection token for form-level default validation messages. */
+declare const DEFAULT_VALIDATION_MESSAGES: InjectionToken<Signal<ValidationMessages | undefined>>;
+/** Injection token for form-level options. */
+declare const FORM_OPTIONS: InjectionToken<Signal<FormOptions | undefined>>;
+/** Injection token for form-level external data. */
+declare const EXTERNAL_DATA: InjectionToken<Signal<Record<string, Signal<unknown>> | undefined>>;
+/**
+ * Form-level DOM-id prefix, provided once at the DynamicForm level and read by
+ * `mapFieldToInputs` as the outermost id segment: `{idPrefix}_{group}_{key}_{index}`.
+ * Scopes ids to one form instance so duplicate forms on a page don't collide.
+ * Inject `{ optional: true }` — absent under mock injectors / standalone usage.
+ */
+declare const FORM_ID_PREFIX: InjectionToken<Signal<string>>;
+
+/** Defines how a field type handles form values and data collection. */
+type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
+/** Semantic grouping of interchangeable field UI alternatives. */
+type FieldScope = 'boolean' | 'single-select' | 'multi-select' | 'text-input' | 'numeric' | 'date';
+/** Mapped component inputs that must be available before a field component is instantiated. */
+type RenderReadyInput = 'field' | (string & {});
+/**
+ * Configuration interface for registering custom field types.
+ *
+ * @typeParam T - The field definition type this field type handles
+ */
+interface FieldTypeDefinition<T extends FieldDef<any> = any> {
+    /** Unique identifier for the field type */
+    name: string;
+    /** Field definition type marker (internal use) */
+    _fieldDef?: T;
+    /**
+     * Function to load the component (supports lazy loading).
+     * Returns a Promise that resolves to the component class or module with default export.
+     */
+    loadComponent?: LazyComponentLoader;
+    /** Mapper function that converts field definition to component bindings. */
+    mapper?: MapperFn<T>;
+    /** How this field type handles form values and data collection (defaults to 'include') */
+    valueHandling?: ValueHandlingMode;
+    /** List of prop keys to forward to the meta object. */
+    propsToMeta?: string[];
+    /** Semantic scope for tooling to discover interchangeable field alternatives */
+    scope?: FieldScope | FieldScope[];
+    /** Mapped component inputs that must exist before the renderer instantiates the component */
+    renderReadyWhen?: readonly RenderReadyInput[];
+    /**
+     * Declares which addon slots this field accepts and (optionally) the
+     * subset of kinds allowed.
+     */
+    addons?: FieldAddonSupport;
+}
+/** Injection token for the global field type registry. */
+declare const FIELD_REGISTRY: InjectionToken<Map<string, FieldTypeDefinition<any>>>;
+/**
+ * Gets the value handling mode for a specific field type from the registry.
+ *
+ * @param fieldType - The field type identifier
+ * @param registry - The field type registry
+ * @returns The value handling mode ('include' is the default if not specified)
+ */
+declare function getFieldValueHandling(fieldType: string, registry: Map<string, FieldTypeDefinition>): ValueHandlingMode;
+
+/** Form mode enumeration distinguishing between paged and non-paged forms */
+type FormMode = 'paged' | 'non-paged';
+/** Result of form mode detection with validation details */
+interface FormModeDetectionResult {
+    /** The detected form mode */
+    mode: FormMode;
+    /** Whether the form configuration is valid for the detected mode */
+    isValid: boolean;
+    /** Array of validation errors if form is invalid */
+    errors: string[];
+}
+/**
+ * Type guard for paged form configurations
+ * A paged form has ALL root-level fields of type 'page'
+ */
+declare function isPagedForm<TFields extends RegisteredFieldTypes[]>(fields: TFields): boolean;
+/**
+ * Type guard for non-paged form configurations
+ * A non-paged form has NO page fields at any level
+ */
+declare function isNonPagedForm<TFields extends RegisteredFieldTypes[]>(fields: TFields): boolean;
+/**
+ * Detects the form mode and validates the configuration
+ *
+ * @param fields The form field definitions
+ * @returns Detection result with mode and validation status
+ */
+declare function detectFormMode<TFields extends RegisteredFieldTypes[]>(fields: TFields): FormModeDetectionResult;
+/** Type predicate for valid paged form configurations */
+declare function isValidPagedForm<TFields extends RegisteredFieldTypes[]>(fields: TFields): boolean;
+/** Type predicate for valid non-paged form configurations */
+declare function isValidNonPagedForm<TFields extends RegisteredFieldTypes[]>(fields: TFields): boolean;
+
+/**
+ * Type guard to check if a field definition has child fields.
+ * This is a looser check that works with FieldDef<unknown> without requiring RegisteredFieldTypes.
+ */
+declare function hasChildFields<T>(field: FieldDef<T>): field is FieldDef<T> & {
+    fields: FieldDef<unknown>[] | Record<string, FieldDef<unknown>>;
+};
+/**
+ * Type guard to check if a field is a container field (page, row, group, or array)
+ * Container fields have a 'fields' property and don't contribute values directly.
+ * This overload works with RegisteredFieldTypes for full type narrowing.
+ */
+declare function isContainerField(field: RegisteredFieldTypes): field is ContainerFieldTypes;
+/**
+ * Type guard to check if a field is a container field (page, row, group, or array).
+ * This overload works with any FieldDef for looser type checking.
+ */
+declare function isContainerField(field: FieldDef<unknown>): boolean;
+/**
+ * Type guard to check if a field is a leaf field (value or display field)
+ * Leaf fields don't have children and either contribute values or display content
+ */
+declare function isLeafField(field: RegisteredFieldTypes): field is LeafFieldTypes;
+/**
+ * Type guard to check if a field has a value property (value-bearing field)
+ * These fields contribute to the form value output
+ * Note: Using `unknown` in the Extract condition to match any value type
+ */
+declare function isValueBearingField(field: RegisteredFieldTypes): field is Extract<RegisteredFieldTypes, {
+    value: unknown;
+}>;
+/**
+ * Type guard to check if a field is excluded from form values (display-only field)
+ * Currently this includes text fields and any other fields without a value property
+ */
+declare function isDisplayOnlyField(field: RegisteredFieldTypes): boolean;
+
+/** Helper types for creating type-safe field configurations with proper nesting constraints */
+
+/**
+ * Type helper for accessing nested field paths safely
+ * This allows accessing child paths while maintaining some type safety
+ */
+type FieldPathAccess<TValue> = {
+    [K in keyof TValue]: SchemaPath<TValue[K]> | SchemaPathTree<TValue[K]>;
+};
+
+/** Configuration for when validation runs based on a field's reactive state. */
+interface ValidationExecutionConfig {
+    /**
+     * Whether validators run while a field is hidden (statically, via `hidden`
+     * logic, or because any ancestor is hidden).
+     */
+    readonly validateWhenHidden?: boolean;
+}
+/** Fully resolved validation execution config — every property defined. */
+type ResolvedValidationExecutionConfig = Required<ValidationExecutionConfig>;
+
+/**
+ * Configuration for excluding field values from form submission output
+ * based on their reactive state (hidden, disabled, readonly).
+ */
+interface ValueExclusionConfig {
+    /**
+     * Whether to exclude the value of hidden fields from submission output.
+     *
+     * @remarks
+     * This does NOT affect HiddenField (`type: 'hidden'`) — those fields
+     * store values without UI and their `hidden()` state is always `false`.
+     */
+    readonly excludeValueIfHidden?: boolean;
+    /** Whether to exclude the value of disabled fields from submission output. */
+    readonly excludeValueIfDisabled?: boolean;
+    /** Whether to exclude the value of readonly fields from submission output. */
+    readonly excludeValueIfReadonly?: boolean;
+}
+/**
+ * Fully resolved exclusion config with all properties required.
+ * Produced by the 3-tier resolution: `field ?? form ?? global`.
+ */
+type ResolvedValueExclusionConfig = Required<ValueExclusionConfig>;
+
+/**
+ * Pipe that handles dynamic text resolution with support for static strings,
+ * Observables, and Signals.
+ */
+declare class DynamicTextPipe implements PipeTransform {
+    private readonly injector;
+    /**
+     * Transforms dynamic text input into a resolved string value
+     *
+     * @param value - The dynamic text value to resolve
+     * @returns The resolved string value as an Observable
+     */
+    transform(value: DynamicText | undefined): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicTextPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DynamicTextPipe, "dynamicText", true>;
+}
+
+/**
+ * Injection token for globally enabling form value emission on events.
+ *
+ * @internal
+ */
+declare const EMIT_FORM_VALUE_ON_EVENTS: InjectionToken<boolean>;
+
+/** Injection token for the dynamic forms logger. */
+declare const DynamicFormLogger: InjectionToken<Logger>;
+
+/**
+ * No-operation logger implementation.
+ * All methods are no-ops - used in production by default.
+ */
+declare class NoopLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+
+/**
+ * Applies meta attributes to a DOM element and tracks which attributes were applied.
+ *
+ * @param element - The DOM element to apply attributes to
+ * @param meta - The meta object containing attributes to apply
+ * @param previouslyApplied - Set of attribute names that were previously applied
+ * @returns A new Set containing the attribute names that were applied
+ */
+declare function applyMetaToElement(element: Element, meta: FieldMeta | undefined, previouslyApplied: Set<string>): Set<string>;
+
+/**
+ * Injection token for the deprecation warning tracker.
+ * Provided at form component level for instance-scoped tracking of deprecated API usages
+ * (keyed by deprecation id) so the same warning fires once per form rather than every render.
+ *
+ * @internal
+ */
+declare const DEPRECATION_WARNING_TRACKER: InjectionToken<WarningTracker>;
+
+/** Options for derivedFromDeferred. */
+interface DerivedFromDeferredOptions<R> {
+    initialValue: R;
+    injector: Injector;
+}
+/** Type helper to extract the value type from a Signal. */
+type SignalValue<T> = T extends Signal<infer V> ? V : never;
+/** Type helper to map an array of Signals to an array of their value types. */
+type SignalValues<T extends readonly Signal<unknown>[]> = {
+    [K in keyof T]: SignalValue<T[K]>;
+};
+/** Type helper to map an object of Signals to an object of their value types. */
+type SignalObjectValues<T extends Record<string, Signal<unknown>>> = {
+    [K in keyof T]: SignalValue<T[K]>;
+};
+/**
+ * Like derivedFrom from ngxtension, but uses defer() to avoid input availability issues.
+ * This ensures toObservable is called at subscription time, not at field initialization.
+ */
+declare function derivedFromDeferred<T, R>(source: Signal<T>, operator: OperatorFunction<T, R>, options: DerivedFromDeferredOptions<R>): Signal<R>;
+declare function derivedFromDeferred<T extends readonly Signal<unknown>[], R>(sources: [...T], operator: OperatorFunction<SignalValues<T>, R>, options: DerivedFromDeferredOptions<R>): Signal<R>;
+declare function derivedFromDeferred<T extends Record<string, Signal<unknown>>, R>(sources: T, operator: OperatorFunction<SignalObjectValues<T>, R>, options: DerivedFromDeferredOptions<R>): Signal<R>;
+
+/**
+ * Converts DynamicText (string | Observable | Signal) to Observable<string>
+ * Unifies all three types into a consistent Observable stream
+ *
+ * @param value - The dynamic text value to convert
+ * @param injector - Optional injector for signal conversion
+ * @returns Observable<string> - The value as an observable stream
+ */
+declare function dynamicTextToObservable(value: DynamicText | undefined, injector?: Injector): Observable<string>;
+
+/** Normalises a {@link DynamicValue} into a `Signal<T>`. */
+declare function resolveDynamicValue<T>(value: DynamicValue<T> | undefined, fallback: T, injector?: Injector): Signal<T>;
+
+/**
+ * Generates CSS class string for responsive grid layout based on field column configuration.
+ *
+ * @param fieldDef - Field definition containing column configuration
+ * @returns CSS class string for grid layout, empty if no valid column configuration
+ */
+declare function getGridClassString(fieldDef: FieldDef<unknown>): string;
+/**
+ * Builds a combined className string from a field definition.
+ *
+ * @param fieldDef - Field definition containing className and col properties
+ * @returns Combined class string, or undefined if no classes
+ */
+declare function buildClassName(fieldDef: FieldDef<unknown>): string | undefined;
+
+/**
+ * Injection token for configuring the initialization timeout in milliseconds.
+ * Defaults to 10 seconds. When the timeout is reached, a warning is logged
+ * and (initialized) emits true as a best-effort fallback.
+ */
+declare const INITIALIZATION_TIMEOUT_MS: InjectionToken<number>;
+/** Creates an observable that tracks component initialization progress. */
+declare function createInitializationTracker(eventBus: EventBus, expectedCount: number): Observable<boolean>;
+/** Options for setting up initialization tracking. */
+interface InitializationTrackingOptions {
+    eventBus: EventBus;
+    totalComponentsCount: Signal<number>;
+    injector: Injector;
+    componentId: string;
+}
+/**
+ * Creates an observable that tracks when all form components are initialized.
+ * Uses shareReplay({ bufferSize: 1, refCount: false }) to ensure exactly one emission
+ * that can be received by late subscribers and keeps the subscription alive.
+ */
+declare function setupInitializationTracking(options: InitializationTrackingOptions): Observable<boolean>;
+
+/**
+ * Interpolates {{param}} placeholders in message with error values
+ *
+ * @param message - Message template with {{param}} placeholders
+ * @param error - Validation error containing parameter values
+ * @returns Message with interpolated parameters
+ */
+declare function interpolateParams(message: string, error: ValidationError): string;
+
+/**
+ * Native JavaScript utility functions to replace lodash-es
+ * These are simple implementations for common object manipulation patterns
+ */
+/**
+ * Performs a deep equality comparison between two values.
+ *
+ * @param a - First value
+ * @param b - Second value
+ * @returns true if values are deeply equal
+ */
+declare function isEqual(a: unknown, b: unknown): boolean;
+/**
+ * Creates a new object without the specified keys
+ * Native replacement for lodash omit()
+ *
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without specified keys
+ */
+declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Creates an object from an array, keyed by a specified property
+ * Native replacement for lodash keyBy()
+ *
+ * @param array - Source array
+ * @param key - Property to use as key
+ * @returns Object keyed by the specified property
+ */
+declare function keyBy<T extends object>(array: T[], key: keyof T): Record<string, T>;
+/**
+ * Maps object values through a transformation function
+ * Native replacement for lodash mapValues()
+ *
+ * @param obj - Source object
+ * @param fn - Transformation function
+ * @returns New object with transformed values
+ */
+declare function mapValues<T, U>(obj: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U>;
+/**
+ * Deep-merges `value` into `defaults`, producing a new object that contains every
+ * key from `defaults` plus any overrides from `value`. Plain-object values at
+ * matching keys are merged recursively; primitives, dates, and class instances
+ * in `value` replace the corresponding default wholesale.
+ */
+declare function deepMergeDefaults<T extends Record<string, unknown>>(defaults: T, value: Record<string, unknown> | null | undefined): T;
+interface MemoizeOptions<TFunc extends (...args: never[]) => unknown> {
+    /** Optional function to generate cache key from arguments */
+    resolver?: (...args: Parameters<TFunc>) => string | number;
+    /** Maximum number of entries to keep in cache. Uses LRU eviction when exceeded. Defaults to 100. */
+    maxSize?: number;
+}
+/**
+ * Memoizes a function with LRU cache eviction and optional custom cache key resolver.
+ *
+ * @param fn - Function to memoize
+ * @param resolverOrOptions - Optional key resolver function or options object
+ * @returns Memoized function
+ */
+declare function memoize<TFunc extends (...args: any[]) => any>(fn: TFunc, resolverOrOptions?: ((...args: Parameters<TFunc>) => string | number) | MemoizeOptions<TFunc>): TFunc;
+/**
+ * Normalizes a fields collection to an array.
+ * Handles both array format and object format (keyed by field key).
+ *
+ * @param fields - Fields as array or object
+ * @returns Fields as array
+ */
+declare function normalizeFieldsArray<T>(fields: readonly T[] | Record<string, T>): T[];
+/**
+ * Gets the keys that differ between two objects.
+ *
+ * @param previous - Previous object state
+ * @param current - Current object state
+ * @returns Set of keys that have different values
+ */
+declare function getChangedKeys(previous: Record<string, unknown> | null | undefined, current: Record<string, unknown> | null | undefined): Set<string>;
+/** Compile-time exhaustiveness check for discriminated unions. */
+declare function assertNever(value: never): never;
+
+/**
+ * Wraps a `Resource` so that the previous resolved value is preserved while the resource
+ * is loading or reloading. This prevents UI flicker when params change and a new request
+ * is in-flight — the consumer sees the stale value with a `loading`/`reloading` status
+ * instead of `undefined`.
+ */
+declare function withPreviousValue<T>(input: Resource<T>): Resource<T>;
+
+/**
+ * Safely reads `pathKeys` from a FieldContext.
+ * Returns an empty array if `pathKeys` is not available (e.g., in tests or older Angular versions).
+ */
+declare function safeReadPathKeys(fieldContext: FieldContext<unknown>): readonly string[];
+
+/**
+ * Serializes a value to a deterministic string for cache key generation.
+ * Unlike JSON.stringify, this sorts object keys to ensure consistent output
+ * regardless of property insertion order.
+ */
+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 };