@ng-forge/dynamic-forms 0.5.0 → 0.5.1

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

@@ -876,6 +876,10 @@ type StateLogicConfig = ImmediateStateLogicConfig | DebouncedStateLogicConfig;
 /**
  * Base configuration for value derivation logic.
  *
+ * All derivations target the field they are defined on (self-targeting).
+ * This simplifies configuration by removing the need for `targetField` -
+ * derivation logic is placed on the field that should receive the computed value.
+ *
  * @internal
  */
 interface BaseDerivationLogicConfig {
@@ -892,29 +896,17 @@ interface BaseDerivationLogicConfig {
      * @example
      * ```typescript
      * {
-     *   type: 'derivation',
-     *   debugName: 'Calculate line total',
-     *   targetField: '$.lineTotal',
-     *   expression: 'formValue.quantity * formValue.unitPrice'
+     *   key: 'lineTotal',
+     *   type: 'input',
+     *   logic: [{
+     *     type: 'derivation',
+     *     debugName: 'Calculate line total',
+     *     expression: 'formValue.quantity * formValue.unitPrice'
+     *   }]
      * }
      * ```
      */
     debugName?: string;
-    /**
-     * The field whose value will be modified.
-     *
-     * Can be:
-     * - Absolute path: 'fieldName' or 'nested.field.path'
-     * - Relative path for arrays: '$.siblingField' (same index as source)
-     *
-     * @example
-     * ```typescript
-     * targetField: 'phonePrefix'           // Absolute path
-     * targetField: 'address.country'       // Nested path
-     * targetField: '$.lineTotal'           // Relative path (array sibling)
-     * ```
-     */
-    targetField: string;
     /**
      * Condition that determines when this derivation applies.
      *
@@ -942,7 +934,7 @@ interface BaseDerivationLogicConfig {
      */
     condition?: ConditionalExpression | boolean;
     /**
-     * Static value to set on the target field.
+     * Static value to set on this field.
      *
      * Use when the derived value is a constant.
      * Mutually exclusive with `expression` and `functionName`.
@@ -960,6 +952,7 @@ interface BaseDerivationLogicConfig {
      * JavaScript expression to evaluate for the derived value.
      *
      * Has access to `formValue` object containing all form values.
+     * For array fields, `formValue` is scoped to the current array item.
      * Uses the same secure AST-based parser as other expressions.
      * Mutually exclusive with `value` and `functionName`.
      *
@@ -1001,18 +994,22 @@ interface BaseDerivationLogicConfig {
      * ```typescript
      * // Only re-evaluate when country changes
      * {
-     *   type: 'derivation',
-     *   targetField: 'currency',
-     *   functionName: 'getCurrencyForCountry',
-     *   dependsOn: ['country']
+     *   key: 'currency',
+     *   logic: [{
+     *     type: 'derivation',
+     *     functionName: 'getCurrencyForCountry',
+     *     dependsOn: ['country']
+     *   }]
      * }
      *
      * // Override automatic detection for complex expressions
      * {
-     *   type: 'derivation',
-     *   targetField: 'total',
-     *   expression: 'calculateTotal(formValue)',
-     *   dependsOn: ['quantity', 'unitPrice', 'discount']
+     *   key: 'total',
+     *   logic: [{
+     *     type: 'derivation',
+     *     expression: 'calculateTotal(formValue)',
+     *     dependsOn: ['quantity', 'unitPrice', 'discount']
+     *   }]
      * }
      * ```
      */
@@ -1056,53 +1053,57 @@ interface DebouncedDerivationLogicConfig extends BaseDerivationLogicConfig {
  * Configuration for value derivation logic.
  *
  * Enables programmatic value derivation based on conditions.
- * When the condition is met, the target field's value is set
- * using a static value, expression, or custom function.
+ * Derivations are self-targeting: the logic is placed on the field
+ * that should receive the computed value.
  *
  * @example
  * ```typescript
  * // Set phone prefix based on country selection
  * {
- *   type: 'derivation',
- *   targetField: 'phonePrefix',
- *   value: '+1',
- *   condition: {
- *     type: 'fieldValue',
- *     fieldPath: 'country',
- *     operator: 'equals',
- *     value: 'USA'
- *   }
+ *   key: 'phonePrefix',
+ *   logic: [{
+ *     type: 'derivation',
+ *     value: '+1',
+ *     condition: {
+ *       type: 'fieldValue',
+ *       fieldPath: 'country',
+ *       operator: 'equals',
+ *       value: 'USA'
+ *     }
+ *   }]
  * }
  *
  * // Compute total from quantity and price
  * {
- *   type: 'derivation',
- *   targetField: 'total',
- *   expression: 'formValue.quantity * formValue.unitPrice'
+ *   key: 'total',
+ *   derivation: 'formValue.quantity * formValue.unitPrice'
  * }
  *
  * // Use custom function for complex logic
  * {
- *   type: 'derivation',
- *   targetField: 'currency',
- *   functionName: 'getCurrencyForCountry'
+ *   key: 'currency',
+ *   logic: [{
+ *     type: 'derivation',
+ *     functionName: 'getCurrencyForCountry'
+ *   }]
  * }
  *
  * // Self-transform with debounced trigger
  * // (applies after user stops typing)
  * {
- *   type: 'derivation',
- *   targetField: 'email',
- *   expression: 'formValue.email.toLowerCase()',
- *   trigger: 'debounced',
- *   debounceMs: 500
+ *   key: 'email',
+ *   logic: [{
+ *     type: 'derivation',
+ *     expression: 'formValue.email.toLowerCase()',
+ *     trigger: 'debounced',
+ *     debounceMs: 500
+ *   }]
  * }
  *
- * // Relative path for array items
+ * // Array item derivation (formValue is scoped to current item)
  * {
- *   type: 'derivation',
- *   targetField: '$.lineTotal',  // Same array index as source field
- *   expression: 'formValue.quantity * formValue.unitPrice'
+ *   key: 'lineTotal',  // Inside array field
+ *   derivation: 'formValue.quantity * formValue.unitPrice'
  * }
  * ```
  *
@@ -1315,8 +1316,13 @@ type InferValueType<T, V> = T extends {
         type: 'number';
     };
 } ? number : Widen<V>;
-/** Make type optional if field is not required */
+/**
+ * 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;
 /**
@@ -1333,10 +1339,18 @@ type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string
     [P in K]: InferFormValueWithDepth<F, Depth[D]>;
 } : {
     [P in K]: Record<string, unknown>;
+} : never : T extends {
+    type: 'array';
+    key: infer K;
+    fields: infer F;
+} ? K extends string ? F extends RegisteredFieldTypes[] ? {
+    [P in K]: InferFormValueWithDepth<F, Depth[D]>[];
+} : {
+    [P in K]: unknown[];
 } : never : T extends {
     type: 'text';
 } ? never : T extends {
-    type: 'submit' | 'button';
+    type: 'submit' | 'button' | 'next' | 'previous' | 'addArrayItem' | 'removeArrayItem';
 } ? never : T extends {
     key: infer K;
     value: infer V;
@@ -1813,13 +1827,13 @@ interface EvaluationContext<TValue = unknown> {
      *
      * @example
      * ```typescript
-     * // In an array item derivation (e.g., lineItems.$.lineTotal):
+     * // In an array item derivation (on the lineTotal field inside lineItems array):
      * {
-     *   type: 'derivation',
-     *   targetField: '$.lineTotal',
+     *   key: 'lineTotal',
+     *   type: 'input',
      *   // formValue = current array item { quantity: 2, unitPrice: 50 }
      *   // rootFormValue = entire form { globalDiscount: 0.1, lineItems: [...] }
-     *   expression: 'formValue.quantity * formValue.unitPrice * (1 - rootFormValue.globalDiscount)'
+     *   derivation: 'formValue.quantity * formValue.unitPrice * (1 - rootFormValue.globalDiscount)'
      * }
      * ```
      *
@@ -1835,6 +1849,28 @@ interface EvaluationContext<TValue = unknown> {
      * Path to the array field when inside an array derivation.
      */
     arrayPath?: string;
+    /**
+     * External data signals resolved to their current values.
+     *
+     * This allows forms to reference data from outside the form context
+     * in conditional logic, derivations, and other expressions.
+     *
+     * @example
+     * ```typescript
+     * // In form config:
+     * externalData: {
+     *   userRole: computed(() => this.userService.currentRole()),
+     *   permissions: computed(() => this.authService.permissions()),
+     * }
+     *
+     * // In JavaScript expression:
+     * condition: {
+     *   type: 'javascript',
+     *   expression: "externalData.userRole === 'admin'"
+     * }
+     * ```
+     */
+    externalData?: Record<string, unknown>;
     /** Allow additional properties for flexible expression evaluation */
     [key: string]: unknown;
 }
@@ -2202,6 +2238,54 @@ interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = Reg
      * ```
      */
     defaultProps?: TProps;
+    /**
+     * External data signals available to conditional logic and derivations.
+     *
+     * Provides a way to inject external application state into form expressions.
+     * Each property is a Signal that will be unwrapped and made available in the
+     * `EvaluationContext` under `externalData`.
+     *
+     * The signals are read reactively in logic functions (when/readonly/disabled)
+     * so changes to the external data will trigger re-evaluation of conditions.
+     *
+     * @example
+     * ```typescript
+     * const config: FormConfig = {
+     *   externalData: {
+     *     userRole: computed(() => this.authService.currentRole()),
+     *     permissions: computed(() => this.authService.permissions()),
+     *     featureFlags: computed(() => this.featureFlagService.flags()),
+     *   },
+     *   fields: [
+     *     {
+     *       type: 'input',
+     *       key: 'adminField',
+     *       label: 'Admin Only Field',
+     *       logic: [{
+     *         effect: 'show',
+     *         condition: {
+     *           type: 'javascript',
+     *           expression: "externalData.userRole === 'admin'"
+     *         }
+     *       }]
+     *     },
+     *     {
+     *       type: 'select',
+     *       key: 'advancedOption',
+     *       label: 'Advanced Option',
+     *       logic: [{
+     *         effect: 'show',
+     *         condition: {
+     *           type: 'javascript',
+     *           expression: "externalData.featureFlags.advancedMode === true"
+     *         }
+     *       }]
+     *     }
+     *   ]
+     * };
+     * ```
+     */
+    externalData?: Record<string, Signal<unknown>>;
 }
 /**
  * Signal forms adapter configuration for advanced form behavior.
@@ -2322,14 +2406,15 @@ interface CustomFnConfig {
      *
      * Field configuration using a derivation function:
      * ```typescript
+     * // Derivation is defined on the target field (currency), not the source field (country)
      * {
-     *   key: 'country',
+     *   key: 'currency',
      *   type: 'select',
      *   logic: [
      *     {
      *       type: 'derivation',
-     *       targetField: 'currency',
-     *       functionName: 'getCurrencyForCountry'
+     *       functionName: 'getCurrencyForCountry',
+     *       dependsOn: ['country']
      *     }
      *   ]
      * }
@@ -2594,6 +2679,35 @@ interface FormOptions {
      * ```
      */
     nextButton?: NextButtonOptions;
+    /**
+     * Whether to attach the current form value to all events dispatched through the EventBus.
+     *
+     * This per-form setting overrides the global `withEventFormValue()` feature:
+     * - `true` - Enable form value emission for this form (even if globally disabled)
+     * - `false` - Disable form value emission for this form (even if globally enabled)
+     * - `undefined` - Use global setting (default)
+     *
+     * When enabled, events will include a `formValue` property with the current form state.
+     * Use the `hasFormValue()` type guard to safely access this property.
+     *
+     * @example
+     * ```typescript
+     * // Enable for this form only (no global withEventFormValue() needed)
+     * const config: FormConfig = {
+     *   fields: [...],
+     *   options: { emitFormValueOnEvents: true }
+     * };
+     *
+     * // Disable for this form (when globally enabled)
+     * const config: FormConfig = {
+     *   fields: [...],
+     *   options: { emitFormValueOnEvents: false }
+     * };
+     * ```
+     *
+     * @default undefined (uses global setting)
+     */
+    emitFormValueOnEvents?: boolean;
 }
 /**
  * Options for controlling submit button disabled behavior.
@@ -2727,10 +2841,8 @@ interface DerivationProcessingResult {
 interface DerivationLogEntry {
     /** Debug name if provided in the derivation config */
     debugName?: string;
-    /** Source field key where the derivation is defined */
-    sourceFieldKey: string;
-    /** Target field key that will be modified */
-    targetFieldKey: string;
+    /** Field key where the derivation is defined and targets */
+    fieldKey: string;
     /** Result of the derivation evaluation */
     result: 'applied' | 'skipped' | 'error';
     /** Reason for skipping (if result is 'skipped') */
@@ -2819,7 +2931,38 @@ interface DerivationOrchestratorConfig {
 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.
+     *
+     * Use the `hasFormValue()` type guard to check if this property is present.
+     */
+    readonly formValue?: unknown;
 }
+/**
+ * Type guard to check if a form event has a form value attached.
+ *
+ * Use this to safely access the `formValue` property on events when
+ * `withEventFormValue()` is enabled globally or `options.emitFormValueOnEvents`
+ * is set to `true` in the form config.
+ *
+ * @example
+ * ```typescript
+ * eventBus.on<SubmitEvent>('submit').subscribe(event => {
+ *   if (hasFormValue(event)) {
+ *     console.log('Form value:', event.formValue);
+ *   }
+ * });
+ * ```
+ *
+ * @param event - The form event to check
+ * @returns `true` if the event has a form value attached, narrowing the type
+ *
+ * @public
+ */
+declare function hasFormValue<T extends FormEvent>(event: T): event is T & {
+    formValue: unknown;
+};
 /**
  * Constructor type for form event classes.
  *
@@ -2976,6 +3119,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
         maxDerivationIterations?: number;
         submitButton?: _ng_forge_dynamic_forms.SubmitButtonOptions;
         nextButton?: _ng_forge_dynamic_forms.NextButtonOptions;
+        emitFormValueOnEvents?: boolean;
     }>;
     /**
      * Computed derivation logger based on injected config.
@@ -3031,10 +3175,15 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Emits when form dirty state changes. */
     readonly dirtyChange: _angular_core.OutputRef<boolean>;
     /**
-     * Emits form values when submitted (via SubmitEvent).
+     * Emits form values when submitted (via SubmitEvent) and form is valid.
+     *
+     * **Important:** This output only emits when the form is valid. If you need to
+     * handle submit events regardless of validity, use the `(events)` output and
+     * filter for `'submit'` events.
+     *
      * Note: Does not emit when `submission.action` is configured - use one or the other.
      */
-    readonly submitted: _angular_core.OutputRef<Partial<TModel> | undefined>;
+    readonly submitted: _angular_core.OutputRef<TModel>;
     /** Emits when form is reset to default values. */
     readonly reset: _angular_core.OutputRef<FormResetEvent>;
     /** Emits when form is cleared to empty state. */
@@ -3099,13 +3248,9 @@ type ExtractFieldDef<T> = T extends FieldTypeDefinition<infer F> ? F : never;
  */
 type FieldDefUnion<T extends FieldTypeDefinition[]> = ExtractFieldDef<T[number]>;
 /**
- * Infer form value type from field definitions
- * Note: Full value type inference requires complex recursive type mapping.
- * Using unknown as placeholder until full inference is implemented.
+ * Infer form value type from field definitions using the real inference type.
  */
-type InferFormValue<TFieldDefs extends FieldDef<unknown>[]> = {
-    [K in TFieldDefs[number]['key']]: unknown;
-};
+type InferFormValue<TFieldDefs extends FieldDef<unknown>[]> = InferFormValue$1<TFieldDefs>;
 /**
  * Provider result with type inference
  */
@@ -3318,6 +3463,52 @@ declare class NoopLogger implements Logger {
     error(): void;
 }
 
+/**
+ * Enables automatic form value attachment to all events dispatched through the EventBus.
+ *
+ * When this feature is enabled, events dispatched via `eventBus.dispatch()` will include
+ * the current form value in the `formValue` property. This is useful for event handlers
+ * that need access to the complete form state at the time of the event.
+ *
+ * @example Global opt-in
+ * ```typescript
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withEventFormValue()
+ * )
+ * ```
+ *
+ * @example Consumer usage
+ * ```typescript
+ * eventBus.on<SubmitEvent>('submit').subscribe(event => {
+ *   if (hasFormValue(event)) {
+ *     console.log('Form value:', event.formValue);
+ *   }
+ * });
+ * ```
+ *
+ * @example Per-form disable (when globally enabled)
+ * ```typescript
+ * const config: FormConfig = {
+ *   fields: [...],
+ *   options: { emitFormValueOnEvents: false }
+ * };
+ * ```
+ *
+ * @remarks
+ * **Precedence rules:**
+ * 1. Per-form `false` - Disables for this form, regardless of global setting
+ * 2. Per-form `true` - Enables for this form, regardless of global setting
+ * 3. Per-form `undefined` - Uses global setting
+ * 4. Global `withEventFormValue()` - Enables globally
+ * 5. No global feature - Disabled globally (default)
+ *
+ * @returns A DynamicFormFeature that enables form value attachment to events
+ *
+ * @public
+ */
+declare function withEventFormValue(): DynamicFormFeature<'event-form-value'>;
+
 interface FieldOption<T = unknown> {
     label: DynamicText;
     value: T;
@@ -3728,7 +3919,10 @@ declare class RemoveArrayItemEvent implements FormEvent {
  * ```
  */
 declare class EventBus {
-    private pipeline$;
+    private readonly pipeline$;
+    private readonly globalEmitFormValue;
+    private readonly rootFormRegistry;
+    private readonly formOptions;
     events$: Observable<FormEvent>;
     /**
      * Dispatches an event to all subscribers.
@@ -3736,6 +3930,10 @@ declare class EventBus {
      * 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
@@ -3748,6 +3946,14 @@ declare class EventBus {
      * ```
      */
     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.
      *
@@ -3873,6 +4079,64 @@ declare function formConfig<const TFields extends NarrowFields, TProps extends o
     schema?: FormSchema<InferFormValue$1<TFields>>;
 }): FormConfig<TFields, InferFormValue$1<TFields>, TProps>;
 
+/**
+ * Creates a typed field configuration with helpful error messages for common mistakes.
+ *
+ * This helper function provides early validation and clear error messages
+ * for common configuration pitfalls that would otherwise cause runtime errors.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const nameField = createField('input', {
+ *   key: 'name',
+ *   label: 'Name',
+ *   value: ''
+ * });
+ *
+ * // With validation
+ * const emailField = createField('input', {
+ *   key: 'email',
+ *   label: 'Email',
+ *   required: true,
+ *   email: true,
+ *   props: { type: 'email' }
+ * });
+ *
+ * // Select with options (at field level)
+ * const countryField = createField('select', {
+ *   key: 'country',
+ *   label: 'Country',
+ *   options: [{ label: 'USA', value: 'us' }]
+ * });
+ *
+ * // Slider with minValue/maxValue (at field level)
+ * const ratingField = createField('slider', {
+ *   key: 'rating',
+ *   label: 'Rating',
+ *   minValue: 1,
+ *   maxValue: 10,
+ *   step: 1,
+ *   value: 5
+ * });
+ * ```
+ *
+ * @param type - The field type (e.g., 'input', 'select', 'group')
+ * @param config - The field configuration (excluding the 'type' property)
+ * @returns A properly typed field configuration
+ * @throws DynamicFormError if the configuration contains common mistakes
+ */
+declare function createField<T extends AvailableFieldTypes>(type: T, config: Omit<ExtractField<T>, 'type'>): ExtractField<T>;
+/**
+ * Shorthand alias for createField
+ *
+ * @example
+ * ```typescript
+ * const nameField = field('input', { key: 'name', label: 'Name', value: '' });
+ * ```
+ */
+declare const field: typeof createField;
+
 /**
  * Base error class for all Dynamic Forms errors.
  *
@@ -4329,5 +4593,5 @@ declare class RootFormRegistryService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<RootFormRegistryService>;
 }
 
-export { ARRAY_CONTEXT, AddArrayItemEvent, 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, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RootFormRegistryService, RowFieldComponent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, dynamicTextToObservable, formConfig, getArrayLength, groupFieldMapper, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withLoggerConfig };
+export { ARRAY_CONTEXT, AddArrayItemEvent, 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, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RootFormRegistryService, RowFieldComponent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig };
 export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };