@ng-forge/dynamic-forms 0.6.0 → 0.6.1

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

@@ -3,7 +3,7 @@ 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 * as _angular_forms_signals from '@angular/forms/signals';
-import { FieldTree, FieldContext, ValidationError as ValidationError$1, TreeValidationResult, SchemaPath, SchemaPathTree } 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';
 import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
 import { FormSchema } from '@ng-forge/dynamic-forms/schema';
@@ -2362,19 +2362,36 @@ type MaybeOptional<T, V> = T extends {
 } ? 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, else string.
+ */
+type InferSingleTemplateValue<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;
+} ? Widen<V, Depth[D]> : string;
 /**
  * Infers the value type for an array field.
- * Handles three cases:
+ * Handles four cases:
  * 1. Simplified array with template + value → infer item type from value
- * 2. Simplified array with template only → unknown[]
- * 3. Full-API array with fields → infer from children
+ * 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: unknown;
-} ? unknown[] : 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[];
 /**
@@ -2457,11 +2474,11 @@ type InferFormValue$1<T> = ExtractFields<T> extends readonly RegisteredFieldType
  */
 interface HttpValidationResponseMapping {
     /**
-     * Expression evaluated with scope `{ response }`. Truthy = valid (no error).
+     * Expression evaluated with scope `{ response }`. Must evaluate to `true` (strict boolean) to be valid.
      *
      * NOTE: This is the OPPOSITE of the function-based HttpCustomValidator.onSuccess
      * convention, which maps successful HTTP responses to validation errors.
-     * Here, truthy means "validation passed".
+     * Here, `=== true` means "validation passed". Non-boolean results are treated as invalid and trigger a warning.
      */
     validWhen: string;
     /** Error kind returned when validation fails — maps to field-level `validationMessages` */
@@ -2963,7 +2980,7 @@ type FormFieldStateMap = Record<string, FieldStateInfo | undefined>;
  */
 type FieldStateContext = FieldStateInfo;
 
-interface EvaluationContext<TValue = unknown> {
+interface EvaluationContext<TValue = unknown, TFormValue extends Record<string, unknown> = any> {
     /** Current field value */
     fieldValue: TValue;
     /**
@@ -2973,7 +2990,7 @@ interface EvaluationContext<TValue = unknown> {
      * For array item derivations, this is scoped to the current array item.
      * Use `rootFormValue` to access the complete form when inside an array context.
      */
-    formValue: Record<string, unknown>;
+    formValue: TFormValue;
     /** Field path for relative references */
     fieldPath: string;
     /** Custom evaluation functions */
@@ -3114,7 +3131,7 @@ interface EvaluationContext<TValue = unknown> {
  * };
  * ```
  */
-type CustomFunction = (context: EvaluationContext) => unknown;
+type CustomFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => unknown;
 
 /**
  * Async function for derivations — returns any value.
@@ -3133,7 +3150,7 @@ type CustomFunction = (context: EvaluationContext) => unknown;
  *
  * @public
  */
-type AsyncDerivationFunction = (context: EvaluationContext) => Promise<unknown> | Observable<unknown>;
+type AsyncDerivationFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<unknown> | Observable<unknown>;
 /**
  * Async function for conditions — returns boolean.
  *
@@ -3151,7 +3168,7 @@ type AsyncDerivationFunction = (context: EvaluationContext) => Promise<unknown>
  *
  * @public
  */
-type AsyncConditionFunction = (context: EvaluationContext) => Promise<boolean> | Observable<boolean>;
+type AsyncConditionFunction<TFormValue extends Record<string, unknown> = any> = (context: EvaluationContext<unknown, TFormValue>) => Promise<boolean> | Observable<boolean>;
 
 /**
  * Re-export Angular's ValidationError for consistency
@@ -3416,7 +3433,7 @@ interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = Reg
     /**
      * Signal forms adapter configuration.
      */
-    customFnConfig?: CustomFnConfig;
+    customFnConfig?: CustomFnConfig<TValue extends Record<string, unknown> ? TValue : Record<string, unknown>>;
     /**
      * Form submission configuration.
      *
@@ -3571,7 +3588,7 @@ interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = Reg
  *
  * @public
  */
-interface CustomFnConfig {
+interface CustomFnConfig<TFormValue extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Custom evaluation functions for conditional expressions.
      *
@@ -3589,7 +3606,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    customFunctions?: Record<string, CustomFunction>;
+    customFunctions?: Record<string, CustomFunction<TFormValue>>;
     /**
      * Custom derivation functions for value derivation logic.
      *
@@ -3657,7 +3674,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    derivations?: Record<string, CustomFunction>;
+    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.
@@ -3700,7 +3717,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    propertyDerivations?: Record<string, CustomFunction>;
+    propertyDerivations?: Record<string, CustomFunction<TFormValue>>;
     /**
      * Async derivation functions for asynchronous value derivation logic.
      *
@@ -3730,7 +3747,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    asyncDerivations?: Record<string, AsyncDerivationFunction>;
+    asyncDerivations?: Record<string, AsyncDerivationFunction<TFormValue>>;
     /**
      * Async condition functions for asynchronous field state logic.
      *
@@ -3754,7 +3771,7 @@ interface CustomFnConfig {
      * }
      * ```
      */
-    asyncConditions?: Record<string, AsyncConditionFunction>;
+    asyncConditions?: Record<string, AsyncConditionFunction<TFormValue>>;
     /**
      * Custom validators using Angular's public FieldContext API
      *
@@ -4324,15 +4341,10 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     private injector;
     private eventBus;
     private logger;
-    /**
-     * Connect input signals to the shared deps holder BEFORE injecting FormStateManager.
-     * Field initializers run in declaration order, so this runs after inputs are created
-     * but before stateManager is injected. FormStateManager reads from these signals
-     * in computeds/effects, which are all lazy and evaluated after construction.
-     */
-    private readonly _connectStateDeps;
-    /** State manager that owns all form state. */
-    private stateManager;
+    private dispatcher;
+    /** State manager that owns all form state. Initialized via connectDeps() to guarantee
+     * FORM_STATE_DEPS is populated before FormStateManager is injected. */
+    private readonly stateManager;
     private componentId;
     /** The currently active config used for form rendering */
     activeConfig: Signal<FormConfig<TFields, InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, Record<string, unknown>, unknown> | undefined>;
@@ -4370,7 +4382,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Whether any form field has been touched (blurred) */
     touched: Signal<boolean>;
     /** Current validation errors from all fields */
-    errors: Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    errors: Signal<_angular_forms_signals.ValidationError.WithFieldTree[]>;
     /** Whether the form is disabled (from options or form state) */
     disabled: Signal<boolean>;
     /** Whether the form is currently submitting */
@@ -4381,6 +4393,13 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     shouldRender: Signal<boolean>;
     /** Resolved fields ready for rendering */
     protected resolvedFields: Signal<ResolvedField[]>;
+    /**
+     * Recursively counts container components that will emit ComponentInitializedEvent.
+     * Includes the dynamic-form component itself (+1).
+     *
+     * Recurses into all container children, including those nested inside array
+     * item templates, to avoid a premature (initialized) emission.
+     */
     private totalComponentsCount;
     initialized$: rxjs.Observable<boolean>;
     /** Emits when form validity changes. */
@@ -4426,11 +4445,176 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
      */
     protected onNativeSubmit(event: Event): void;
     private setupEffects;
+    /**
+     * Populates FORM_STATE_DEPS with this component's input signals, then injects
+     * FormStateManager. Must be called as a field initializer (after the input signals
+     * are declared) so that FormStateManager reads populated deps when it is constructed.
+     * inject() is valid here because field initializers run inside the injection context.
+     */
+    private connectDeps;
     private setupEventHandlers;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicForm<any, any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicForm<any, any>, "form[dynamic-form]", never, { "config": { "alias": "dynamic-form"; "required": true; "isSignal": true; }; "formOptions": { "alias": "formOptions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; "reset": "reset"; "cleared": "cleared"; "events": "events"; "initialized": "initialized"; "onPageChange": "onPageChange"; "onPageNavigationStateChange": "onPageNavigationStateChange"; }, never, never, true, never>;
 }
 
+declare class EventBus {
+    private readonly pipeline$;
+    private readonly globalEmitFormValue;
+    private readonly rootFormRegistry;
+    private readonly formOptions;
+    private readonly logger;
+    events$: Observable<FormEvent>;
+    /**
+     * Dispatches a pre-created event instance directly.
+     *
+     * Use this overload with the `arrayEvent()` factory or any other code that
+     * produces a `FormEvent` instance rather than a constructor:
+     *
+     * ```typescript
+     * eventBus.dispatch(arrayEvent('contacts').append(template));
+     * eventBus.dispatch(arrayEvent('contacts').pop());
+     * ```
+     *
+     * @param event - A FormEvent instance to dispatch
+     */
+    dispatch(event: FormEvent): void;
+    /**
+     * Dispatches an event to all subscribers by instantiating the provided constructor.
+     *
+     * Creates an instance of the provided event constructor and broadcasts it
+     * through the event pipeline to all active subscribers.
+     *
+     * If `withEventFormValue()` is enabled globally or `options.emitFormValueOnEvents`
+     * is set to `true` in the form config, the current form value will be attached
+     * to the event's `formValue` property.
+     *
+     * @param eventConstructor - Constructor function for the event to dispatch
+     * @param args - Arguments to pass to the event constructor
+     *
+     * @example
+     * ```typescript
+     * // Dispatch a submit event
+     * eventBus.dispatch(SubmitEvent);
+     *
+     * // Dispatch a custom event with args
+     * eventBus.dispatch(CustomFormEvent, 'arg1', 42);
+     * ```
+     */
+    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.
+     *
+     * Precedence rules:
+     * 1. Per-form setting (if defined) takes precedence
+     * 2. Falls back to global setting
+     */
+    private shouldEmitFormValue;
+    /**
+     * Subscribes to events of a specific type.
+     *
+     * @param eventType - The type of event to subscribe to
+     * @returns Observable that emits events of the specified type
+     */
+    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
+    /**
+     * Subscribes to events of multiple types.
+     *
+     * @param eventType - Array of event types to subscribe to
+     * @returns Observable that emits events matching any of the specified types
+     */
+    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventBus, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventBus>;
+}
+
+/**
+ * Injectable service for dispatching events into a DynamicForm from outside the form.
+ *
+ * ## When to use
+ *
+ * Use `EventDispatcher` when you need to drive form behaviour **from the host component** —
+ * for example, appending array items in response to a field value change, triggering a form
+ * reset from a toolbar button, or reacting to external application state.
+ *
+ * This is the recommended alternative to accessing the form's internals via `viewChild`.
+ *
+ * ## Setup
+ *
+ * Provide `EventDispatcher` at the **host component** level (not root). DynamicForm
+ * automatically detects it and connects its internal event bus to the dispatcher.
+ *
+ * ```typescript
+ * @Component({
+ *   providers: [EventDispatcher],
+ *   template: `<form [dynamic-form]="config" [(value)]="formValue"></form>`
+ * })
+ * export class MyComponent {
+ *   readonly dispatcher = inject(EventDispatcher);
+ *   readonly formValue = signal<Record<string, unknown>>({});
+ *
+ *   constructor() {
+ *     effect(() => {
+ *       const category = this.formValue()?.['category'] as string | undefined;
+ *       if (category) {
+ *         this.dispatcher.dispatch(
+ *           arrayEvent('tasks').append([{ key: 'name', type: 'input', label: 'Task', value: category }])
+ *         );
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * ## Multi-form note
+ *
+ * If multiple `DynamicForm` instances exist under the same provider scope, **all forms**
+ * will receive dispatched events. To target a specific form, scope the provider to a
+ * wrapper component that contains only that form.
+ *
+ * ## What events can be dispatched
+ *
+ * Any `FormEvent` instance is accepted — array events, reset/clear events, custom events, etc.
+ * The `arrayEvent()` builder is the recommended way to construct array manipulation events:
+ *
+ * ```typescript
+ * dispatcher.dispatch(arrayEvent('tasks').append(template));
+ * dispatcher.dispatch(arrayEvent('tasks').removeAt(0));
+ * dispatcher.dispatch(new FormResetEvent());
+ * ```
+ */
+declare class EventDispatcher {
+    private bus;
+    /**
+     * Dispatches a form event into the connected DynamicForm's event bus.
+     * No-op if no form is currently connected.
+     *
+     * @param event - A FormEvent instance. Use the `arrayEvent()` builder for array operations.
+     */
+    dispatch(event: FormEvent): void;
+    /** @internal - Called by DynamicForm on init */
+    connect(bus: EventBus): void;
+    /** @internal - Called by DynamicForm on destroy */
+    disconnect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventDispatcher, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventDispatcher>;
+}
+
 /**
  * Base interface for dynamic form features.
  * Features are configuration options that can be passed to provideDynamicForm
@@ -5444,92 +5628,6 @@ declare function arrayEvent(arrayKey: string): {
     removeAt: (index: number) => RemoveAtIndexEvent;
 };
 
-/**
- * Event bus service for form-wide event communication.
- *
- * Provides type-safe event dispatching and subscription for form components
- * to communicate without direct coupling. Uses RxJS observables for reactive
- * event handling and supports both single event type and multiple event type subscriptions.
- *
- * @example
- * ```typescript
- * @Component({
- *   providers: [EventBus]
- * })
- * export class MyFormComponent {
- *   constructor(private eventBus: EventBus) {
- *     // Subscribe to form submission events
- *     this.eventBus.on<SubmitEvent>('submit').subscribe(() => {
- *       console.log('Form was submitted');
- *     });
- *
- *     // Subscribe to multiple event types
- *     this.eventBus.on<SubmitEvent | FormResetEvent>(['submit', 'form-reset']).subscribe(event => {
- *       console.log('Form event:', event.type);
- *     });
- *   }
- *
- *   onSubmit() {
- *     // Dispatch a submit event
- *     this.eventBus.dispatch(SubmitEvent);
- *   }
- * }
- * ```
- */
-declare class EventBus {
-    private readonly pipeline$;
-    private readonly globalEmitFormValue;
-    private readonly rootFormRegistry;
-    private readonly formOptions;
-    events$: Observable<FormEvent>;
-    /**
-     * Dispatches an event to all subscribers.
-     *
-     * Creates an instance of the provided event constructor and broadcasts it
-     * through the event pipeline to all active subscribers.
-     *
-     * If `withEventFormValue()` is enabled globally or `options.emitFormValueOnEvents`
-     * is set to `true` in the form config, the current form value will be attached
-     * to the event's `formValue` property.
-     *
-     * @param eventConstructor - Constructor function for the event to dispatch
-     *
-     * @example
-     * ```typescript
-     * // Dispatch a submit event
-     * eventBus.dispatch(SubmitEvent);
-     *
-     * // Dispatch a custom event
-     * eventBus.dispatch(CustomFormEvent);
-     * ```
-     */
-    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
-    /**
-     * Determines whether form value should be attached to events.
-     *
-     * Precedence rules:
-     * 1. Per-form setting (if defined) takes precedence
-     * 2. Falls back to global setting
-     */
-    private shouldEmitFormValue;
-    /**
-     * Subscribes to events of a specific type.
-     *
-     * @param eventType - The type of event to subscribe to
-     * @returns Observable that emits events of the specified type
-     */
-    on<T extends FormEvent>(eventType: T['type']): Observable<T>;
-    /**
-     * Subscribes to events of multiple types.
-     *
-     * @param eventType - Array of event types to subscribe to
-     * @returns Observable that emits events matching any of the specified types
-     */
-    on<T extends FormEvent>(eventType: Array<T['type']>): Observable<T>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EventBus, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EventBus>;
-}
-
 /**
  * Context for token resolution in event args
  */
@@ -5946,7 +6044,7 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     readonly invalid: _angular_core.Signal<boolean>;
     readonly dirty: _angular_core.Signal<boolean>;
     readonly touched: _angular_core.Signal<boolean>;
-    readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithFieldTree[]>;
     readonly disabled: _angular_core.Signal<boolean>;
     private readonly nestedFieldTree;
     private readonly groupFieldSignalContext;
@@ -6007,7 +6105,7 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     key: _angular_core.InputSignal<string>;
     className: _angular_core.InputSignal<string | undefined>;
     hidden: _angular_core.InputSignal<boolean>;
-    readonly hostClasses: _angular_core.Signal<string>;
+    readonly hostClasses: Signal<string>;
     private readonly rawFieldRegistry;
     /**
      * Gets the auto-remove button FieldDef from normalization metadata.
@@ -6052,7 +6150,12 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
      */
     private readonly itemPositionMap;
     /** Read-only view of resolved items for template consumption. */
-    readonly resolvedItems: _angular_core.Signal<ResolvedArrayItem[]>;
+    readonly resolvedItems: Signal<ResolvedArrayItem[]>;
+    /**
+     * Whether the array has reached its configured maxLength.
+     * Exposed as a public signal so add-button components can bind [disabled]="atMaxLength()".
+     */
+    readonly atMaxLength: Signal<boolean>;
     /**
      * Caches the result of appending the auto-remove button to template arrays.
      * Keyed by template array reference — cache hits occur during recreate/resolution
@@ -6191,5 +6294,12 @@ declare class RootFormRegistryService {
     constructor(formValue: Signal<Record<string, unknown>>, rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>);
 }
 
-export { ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, 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 };
+/**
+ * Injection token for configuring the initialization timeout in milliseconds.
+ * Defaults to 10 seconds. When the timeout is reached, a warning is logged
+ * and (initialized) emits true as a best-effort fallback.
+ */
+declare const INITIALIZATION_TIMEOUT_MS: InjectionToken<number>;
+
+export { 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 };