@ng-forge/dynamic-forms 0.6.1 → 0.7.0

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

@@ -1,7 +1,7 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as _angular_core from '@angular/core';
-import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
+import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, EnvironmentInjector, Provider, EnvironmentProviders, Resource, PipeTransform } from '@angular/core';
 import * as _angular_forms_signals from '@angular/forms/signals';
 import { FieldTree, FieldContext, TreeValidationResult, ValidationError as ValidationError$1, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
 import * as _angular_forms from '@angular/forms';
@@ -379,6 +379,14 @@ type MapperFn<T extends FieldDef<unknown>> = (input: T) => Signal<Record<string,
  * - 'flatten': Field's children are flattened to parent level (for container fields)
  */
 type ValueHandlingMode = 'include' | 'exclude' | 'flatten';
+/**
+ * Semantic grouping of interchangeable field UI alternatives.
+ *
+ * Used by tooling (e.g., openapi-generator) to discover which field types
+ * can substitute for each other. A field with scope 'boolean' means it's
+ * one of several ways to render a boolean value (checkbox, toggle, etc.).
+ */
+type FieldScope = 'boolean' | 'single-select' | 'multi-select' | 'text-input' | 'numeric' | 'date';
 /**
  * Configuration interface for registering custom field types.
  *
@@ -444,6 +452,8 @@ interface FieldTypeDefinition<T extends FieldDef<any> = any> {
      * ```
      */
     propsToMeta?: string[];
+    /** Semantic scope for tooling to discover interchangeable field alternatives */
+    scope?: FieldScope | FieldScope[];
 }
 /**
  * Injection token for the global field type registry.
@@ -533,56 +543,17 @@ interface FieldValueCondition {
     value?: unknown;
 }
 /**
- * Condition that compares the entire form value against an expected value.
- *
- * @deprecated Use `FieldValueCondition` for specific field checks, or
- * `JavascriptCondition` with an expression for complex form-level comparisons.
- * Will be removed in a future minor version.
- *
- * @public
- */
-interface FormValueCondition {
-    type: 'formValue';
-    /** Comparison operator */
-    operator: ComparisonOperator;
-    /** Value to compare against */
-    value?: unknown;
-}
-/**
- * Condition that invokes a registered custom function by name (new API).
+ * Condition that invokes a registered custom function by name.
  *
  * Register functions via `customFnConfig.customFunctions`.
  *
- * @internal
+ * @public
  */
-interface CustomConditionNew {
+interface CustomCondition {
     type: 'custom';
     /** Name of the registered custom function to invoke */
     functionName: string;
 }
-/**
- * @deprecated Use `CustomCondition` with `functionName` instead.
- * The `expression` field was misnamed — it holds a function registry key, not a JS expression.
- * Will be removed in a future minor version.
- *
- * @internal
- */
-interface CustomConditionDeprecated {
-    type: 'custom';
-    /**
-     * @deprecated Use `functionName` instead. Will be removed in a future minor version.
-     */
-    expression: string;
-}
-/**
- * Condition that invokes a registered custom function by name.
- *
- * Use `functionName` (new API). The `expression` field is deprecated.
- * Register functions via `customFnConfig.customFunctions`.
- *
- * @public
- */
-type CustomCondition = CustomConditionNew | CustomConditionDeprecated;
 /**
  * Condition that evaluates a JavaScript expression using the secure AST-based parser.
  *
@@ -697,7 +668,7 @@ interface OrCondition {
  *
  * @public
  */
-type ConditionalExpression = FieldValueCondition | FormValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
+type ConditionalExpression = FieldValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
 
 /**
  * Logic configuration for container fields (page, group, row, array).
@@ -1772,161 +1743,15 @@ type DebouncedFunctionDerivationLogicConfig = FunctionDerivationBase & Debounced
  * @public
  */
 type DerivationLogicConfig = OnChangeHttpDerivationLogicConfig | DebouncedHttpDerivationLogicConfig | OnChangeAsyncFunctionDerivationLogicConfig | DebouncedAsyncFunctionDerivationLogicConfig | OnChangeExpressionDerivationLogicConfig | DebouncedExpressionDerivationLogicConfig | OnChangeValueDerivationLogicConfig | DebouncedValueDerivationLogicConfig | OnChangeFunctionDerivationLogicConfig | DebouncedFunctionDerivationLogicConfig;
-/**
- * Base configuration for property derivation logic.
- *
- * Property derivations compute values for field properties (like `minDate`, `options`,
- * `label`, `placeholder`) based on form values and external data. Unlike value derivations
- * which set the field's value, property derivations update component input properties.
- *
- * All property derivations are self-targeting: the logic is placed on the field whose
- * property should be derived.
- *
- * @internal
- */
-interface BasePropertyDerivationLogicConfig {
-    /**
-     * Logic type identifier for property derivation.
-     */
-    type: 'propertyDerivation';
-    /**
-     * The target property to set on the field component.
-     *
-     * **Depth limit (max 2 levels):** Only simple and single-dot-nested paths are
-     * supported. Paths with 2+ dots (e.g., `'a.b.c'`) will throw a `DynamicFormError`
-     * at runtime. This is an architectural constraint of the override merging strategy.
-     *
-     * Supported formats:
-     * - Simple: `'minDate'`, `'options'`, `'label'`, `'placeholder'`
-     * - Nested (1 dot): `'props.appearance'`, `'meta.autocomplete'`
-     *
-     * **Note:** There is no compile-time validation that the property name matches
-     * an actual input on the field component. Typos will silently write to the
-     * override store with no visible effect. A dev-mode warning is emitted when
-     * the override key doesn't match any existing input property.
-     *
-     * @example
-     * ```typescript
-     * targetProperty: 'minDate'           // ✅ Simple property
-     * targetProperty: 'options'           // ✅ Simple property
-     * targetProperty: 'props.appearance'  // ✅ Single-nested property
-     * targetProperty: 'a.b.c'            // ❌ Throws DynamicFormError (too deep)
-     * ```
-     */
-    targetProperty: string;
-    /**
-     * Optional name for this derivation for debugging purposes.
-     *
-     * When provided, this name appears in property derivation debug logs.
-     */
-    debugName?: string;
-    /**
-     * Condition that determines when this property derivation applies.
-     *
-     * Defaults to `true` (always apply).
-     *
-     * Note: FormStateCondition is not supported for property derivations.
-     */
-    condition?: ConditionalExpression | boolean;
-    /**
-     * Static value to set on the target property.
-     *
-     * Mutually exclusive with `expression` and `functionName`.
-     */
-    value?: unknown;
-    /**
-     * JavaScript expression to evaluate for the derived property value.
-     *
-     * Has access to `formValue` object containing all form values.
-     * For array fields, `formValue` is scoped to the current array item.
-     *
-     * Mutually exclusive with `value` and `functionName`.
-     *
-     * @example
-     * ```typescript
-     * expression: 'formValue.startDate'
-     * expression: 'formValue.quantity > 10 ? "bulk" : "standard"'
-     * ```
-     */
-    expression?: string;
-    /**
-     * Name of a registered custom property derivation function.
-     *
-     * Register functions in `customFnConfig.propertyDerivations`.
-     * Mutually exclusive with `value` and `expression`.
-     */
-    functionName?: string;
-    /**
-     * Explicit field dependencies for property derivations.
-     *
-     * When using `functionName`, you can optionally specify which fields
-     * the function depends on. If not provided with `functionName`, defaults
-     * to all fields ('*').
-     * For `expression`, dependencies are automatically extracted.
-     * For `value`, no dependencies are needed (static value).
-     */
-    dependsOn?: string[];
-}
-/**
- * Property derivation that evaluates immediately on change (default).
- *
- * @internal
- */
-interface OnChangePropertyDerivationLogicConfig extends BasePropertyDerivationLogicConfig {
-    /**
-     * Trigger for immediate evaluation.
-     * @default 'onChange'
-     */
-    trigger?: 'onChange';
-    /** Not allowed for onChange trigger */
-    debounceMs?: never;
-}
-/**
- * Property derivation that evaluates after a debounce period.
- *
- * @internal
- */
-interface DebouncedPropertyDerivationLogicConfig extends BasePropertyDerivationLogicConfig {
-    /**
-     * Trigger for debounced evaluation.
-     */
-    trigger: 'debounced';
-    /**
-     * Debounce duration in milliseconds.
-     * @default 500
-     */
-    debounceMs?: number;
-}
-/**
- * Configuration for property derivation logic.
- *
- * @deprecated Use `DerivationLogicConfig` with `targetProperty` instead.
- * The unified `type: 'derivation'` with `targetProperty` provides the same
- * functionality with a simpler API surface.
- *
- * ```typescript
- * // Before (deprecated)
- * { type: 'propertyDerivation', targetProperty: 'minDate', expression: '...' }
- *
- * // After (preferred)
- * { type: 'derivation', targetProperty: 'minDate', expression: '...' }
- * ```
- *
- * Will be removed in a future minor version.
- *
- * @public
- */
-type PropertyDerivationLogicConfig = OnChangePropertyDerivationLogicConfig | DebouncedPropertyDerivationLogicConfig;
 /**
  * Union type for all logic configurations.
  *
  * - `StateLogicConfig`: For field state changes (hidden, readonly, disabled, required)
- * - `DerivationLogicConfig`: For value derivation
- * - `PropertyDerivationLogicConfig`: For property derivation
+ * - `DerivationLogicConfig`: For value derivation (including property derivation via `targetProperty`)
  *
  * @public
  */
-type LogicConfig = StateLogicConfig | DerivationLogicConfig | PropertyDerivationLogicConfig;
+type LogicConfig = StateLogicConfig | DerivationLogicConfig;
 /**
  * Log level for derivation debug output.
  *
@@ -1946,18 +1771,6 @@ type DerivationLogLevel = 'none' | 'summary' | 'verbose';
  * @public
  */
 declare function isFormStateCondition(condition: StateLogicConfig['condition'] | DerivationLogicConfig['condition']): condition is FormStateCondition;
-/**
- * Type guard to check if a logic config is a PropertyDerivationLogicConfig.
- *
- * @deprecated Use `isDerivationLogicConfig(config) && hasTargetProperty(config)` instead.
- * Will be removed in a future minor version.
- *
- * @param config - The logic config to check
- * @returns true if the config is for property derivation
- *
- * @public
- */
-declare function isPropertyDerivationLogicConfig(config: LogicConfig): config is PropertyDerivationLogicConfig;
 
 /**
  * Interface for dynamic forms logger implementations.
@@ -2544,16 +2357,10 @@ interface CustomValidatorConfig extends BaseValidatorConfig {
  * Async custom validator configuration using Angular's validateAsync API.
  * Returns Observable<ValidationError | ValidationError[] | null>.
  *
- * Accepts both `'async'` (preferred) and `'customAsync'` (deprecated) type literals.
  */
 interface AsyncValidatorConfig extends BaseValidatorConfig {
-    /**
-     * Validator type identifier.
-     *
-     * Use `'async'` for new code. `'customAsync'` is accepted for backward compatibility
-     * but emits a deprecation warning in dev mode.
-     */
-    type: 'async' | 'customAsync';
+    /** Validator type identifier. */
+    type: 'async';
     /** Name of registered async validator function */
     functionName: string;
     /** Optional parameters to pass to validator function */
@@ -2567,28 +2374,15 @@ interface AsyncValidatorConfig extends BaseValidatorConfig {
  *
  * Discriminated from `DeclarativeHttpValidatorConfig` by the presence of `functionName`.
  *
- * Accepts both `'http'` (preferred) and `'customHttp'` (deprecated) type literals.
- *
- * @deprecated Prefer `DeclarativeHttpValidatorConfig` (`type: 'http'` with `http` + `responseMapping`)
- * for fully JSON-serializable validation. Use this form only when function registration is required.
  */
 interface FunctionHttpValidatorConfig extends BaseValidatorConfig {
-    /**
-     * Validator type identifier.
-     *
-     * Use `'http'` for new code. `'customHttp'` is accepted for backward compatibility
-     * but emits a deprecation warning in dev mode.
-     */
-    type: 'http' | 'customHttp';
+    /** Validator type identifier. */
+    type: 'http';
     /** Name of registered HTTP validator configuration */
     functionName: string;
     /** Optional parameters to pass to HTTP validator */
     params?: Record<string, unknown>;
 }
-/**
- * @deprecated Use `FunctionHttpValidatorConfig` instead. Will be removed in a future minor version.
- */
-type HttpValidatorConfig = FunctionHttpValidatorConfig;
 /**
  * Declarative HTTP validator configuration — fully JSON-serializable, no function registration required.
  *
@@ -3675,49 +3469,6 @@ interface CustomFnConfig<TFormValue extends Record<string, unknown> = Record<str
      * ```
      */
     derivations?: Record<string, CustomFunction<TFormValue>>;
-    /**
-     * @deprecated Register functions under `derivations` instead. Use `type: 'derivation'`
-     * with `targetProperty` in field logic configs. Will be removed in a future minor version.
-     *
-     * Custom property derivation functions for reactive property updates.
-     *
-     * These functions compute derived values for field properties (like `minDate`,
-     * `options`, `label`, `placeholder`) and are called when a
-     * `PropertyDerivationLogicConfig` references them by `functionName`.
-     *
-     * Property derivation functions:
-     * - Receive an `EvaluationContext` with access to `formValue`
-     * - Return the value to set on the target property
-     * - Are called reactively when dependencies change
-     *
-     * @example
-     * ```typescript
-     * propertyDerivations: {
-     *   getCitiesForCountry: (context) => {
-     *     const countryCities: Record<string, Array<{ label: string; value: string }>> = {
-     *       'USA': [{ label: 'New York', value: 'ny' }, { label: 'LA', value: 'la' }],
-     *       'Germany': [{ label: 'Berlin', value: 'berlin' }, { label: 'Munich', value: 'munich' }],
-     *     };
-     *     return countryCities[context.formValue.country as string] ?? [];
-     *   },
-     * }
-     * ```
-     *
-     * Field configuration using a property derivation function:
-     * ```typescript
-     * {
-     *   key: 'city',
-     *   type: 'select',
-     *   logic: [{
-     *     type: 'propertyDerivation',
-     *     targetProperty: 'options',
-     *     functionName: 'getCitiesForCountry',
-     *     dependsOn: ['country']
-     *   }]
-     * }
-     * ```
-     */
-    propertyDerivations?: Record<string, CustomFunction<TFormValue>>;
     /**
      * Async derivation functions for asynchronous value derivation logic.
      *
@@ -3889,72 +3640,18 @@ interface CustomFnConfig<TFormValue extends Record<string, unknown> = Record<str
      */
     asyncValidators?: Record<string, AsyncCustomValidator>;
     /**
-     * @deprecated Prefer declarative HTTP validators using `type: 'http'` with `http` + `responseMapping`
-     * in the validators array. Function-based HTTP validators now also use `type: 'http'` with `functionName`.
-     * Will be removed in a future minor version.
-     *
-     * HTTP validators using Angular's validateHttp() API
+     * HTTP validators using Angular's validateHttp() API.
      *
-     * Angular's validateHttp provides HTTP validation with automatic request
-     * cancellation and integration with the resource API.
+     * For function-based HTTP validation with automatic request cancellation.
+     * Prefer declarative HTTP validators (`type: 'http'` with `http` + `responseMapping`)
+     * for fully JSON-serializable validation when possible.
      *
-     * **Structure:**
-     * - `request`: Function that returns URL string or HttpResourceRequest
-     * - `onSuccess`: REQUIRED - Maps HTTP response to validation errors (inverted logic!)
-     * - `onError`: Optional handler for HTTP errors
-     *
-     * **Benefits:**
-     * - Automatic request cancellation when field value changes
-     * - Built-in integration with Angular's resource management
-     * - Simpler than asyncValidators for HTTP use cases
-     *
-     * **Important:** `onSuccess` uses inverted logic - it maps SUCCESSFUL HTTP responses
-     * to validation errors. For example, if the API returns `{ available: false }`,
-     * your `onSuccess` should return `{ kind: 'usernameTaken' }`.
-     *
-     * @example Username Availability Check (GET)
+     * @example
      * ```typescript
      * httpValidators: {
      *   checkUsername: {
-     *     request: (ctx) => {
-     *       const username = ctx.value();
-     *       if (!username) return undefined; // Skip validation if empty
-     *       return `/api/users/check-username?username=${encodeURIComponent(username)}`;
-     *     },
-     *     onSuccess: (response, ctx) => {
-     *       // Inverted logic: successful response may indicate validation failure
-     *       return response.available ? null : { kind: 'usernameTaken' };
-     *     },
-     *     onError: (error, ctx) => {
-     *       console.error('Availability check failed:', error);
-     *       return null; // Don't block form on network errors
-     *     }
-     *   }
-     * }
-     * ```
-     *
-     * @example Address Validation (POST with Body)
-     * ```typescript
-     * httpValidators: {
-     *   validateAddress: {
-     *     request: (ctx) => {
-     *       const zipCode = ctx.value();
-     *       if (!zipCode) return undefined;
-     *
-     *       return {
-     *         url: '/api/validate-address',
-     *         method: 'POST',
-     *         body: {
-     *           street: ctx.valueOf('street' as any),
-     *           city: ctx.valueOf('city' as any),
-     *           zipCode: zipCode
-     *         },
-     *         headers: { 'Content-Type': 'application/json' }
-     *       };
-     *     },
-     *     onSuccess: (response) => {
-     *       return response.valid ? null : { kind: 'invalidAddress' };
-     *     }
+     *     request: (ctx) => `/api/users/check?username=${encodeURIComponent(ctx.value())}`,
+     *     onSuccess: (response) => response.available ? null : { kind: 'usernameTaken' },
      *   }
      * }
      * ```
@@ -4339,6 +4036,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     value: _angular_core.ModelSignal<Partial<TModel> | undefined>;
     private destroyRef;
     private injector;
+    protected environmentInjector: EnvironmentInjector;
     private eventBus;
     private logger;
     private dispatcher;
@@ -5945,6 +5643,26 @@ declare function dynamicTextToObservable(value: DynamicText | undefined, injecto
  */
 declare function applyMetaToElement(element: Element, meta: FieldMeta | undefined, previouslyApplied: Set<string>): Set<string>;
 
+/**
+ * Wraps a `Resource` so that the previous resolved value is preserved while the resource
+ * is loading or reloading. This prevents UI flicker when params change and a new request
+ * is in-flight — the consumer sees the stale value with a `loading`/`reloading` status
+ * instead of `undefined`.
+ *
+ * Uses Angular's `resource.snapshot` + `resourceFromSnapshots` composition pattern.
+ *
+ * @example
+ * ```typescript
+ * const user = withPreviousValue(
+ *   resource({ params: () => userId(), loader: ({ params }) => fetchUser(params) })
+ * );
+ * // user.value() keeps the old user data during loading transitions
+ * ```
+ *
+ * @experimental Uses Angular's experimental resource composition APIs.
+ */
+declare function withPreviousValue<T>(input: Resource<T>): Resource<T>;
+
 /**
  * Pipe that handles dynamic text resolution with support for static strings,
  * Observables, and Signals.
@@ -5992,6 +5710,7 @@ declare class RowFieldComponent {
     private readonly destroyRef;
     private readonly fieldRegistry;
     private readonly injector;
+    protected readonly environmentInjector: EnvironmentInjector;
     private readonly eventBus;
     private readonly logger;
     field: _angular_core.InputSignal<RowField<readonly _ng_forge_dynamic_forms.RowAllowedChildren[]>>;
@@ -6021,6 +5740,7 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly fieldRegistry;
     private readonly parentFieldSignalContext;
     private readonly injector;
+    protected readonly environmentInjector: EnvironmentInjector;
     private readonly eventBus;
     private readonly logger;
     private readonly fieldProcessors;
@@ -6097,6 +5817,7 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly fieldRegistry;
     private readonly parentFieldSignalContext;
     private readonly parentInjector;
+    protected readonly environmentInjector: EnvironmentInjector;
     private readonly eventBus;
     private readonly logger;
     private readonly templateRegistry;
@@ -6301,5 +6022,5 @@ declare class RootFormRegistryService {
  */
 declare const INITIALIZATION_TIMEOUT_MS: InjectionToken<number>;
 
-export { ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, EventDispatcher, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, INITIALIZATION_TIMEOUT_MS, InsertArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, RootFormRegistryService, RowFieldComponent, ShiftArrayItemEvent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayEvent, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, evaluateNonFieldDisabled, evaluateNonFieldHidden, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isPropertyDerivationLogicConfig, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig, withValueExclusionDefaults };
-export type { ArrayAllowedChildren, ArrayButtonConfig, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, ArrayItemDefinitionTemplate, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, PageAllowedChildren, PageField, Prettify, PropertyDerivationLogicConfig, RegisteredFieldTypes, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };
+export { ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, EventDispatcher, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, INITIALIZATION_TIMEOUT_MS, InsertArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, RootFormRegistryService, RowFieldComponent, ShiftArrayItemEvent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayEvent, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, evaluateNonFieldDisabled, evaluateNonFieldHidden, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig, withPreviousValue, withValueExclusionDefaults };
+export type { ArrayAllowedChildren, ArrayButtonConfig, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, ArrayItemDefinitionTemplate, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldScope, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };