@ng-forge/dynamic-forms 0.1.0 → 0.1.2

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

@@ -654,6 +654,57 @@ type RegisteredFieldTypes = ContainerFieldTypes | LeafFieldTypes;
  * Extract field types that are available in the registry
  */
 type AvailableFieldTypes = keyof DynamicFormFieldRegistry['containers'] | keyof DynamicFormFieldRegistry['leaves'];
+/**
+ * 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.
+ *
+ * @example
+ * ```typescript
+ * // Extract a specific field type
+ * type MyInputField = ExtractField<'input'>;
+ *
+ * // Use in field definitions for proper props inference
+ * const field: ExtractField<'input'> = {
+ *   type: 'input',
+ *   key: 'email',
+ *   value: '',
+ *   props: { type: 'email' } // Only input props allowed here
+ * };
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```typescript
+ * function processField<T extends RegisteredFieldTypes>(field: T): NarrowField<T> {
+ *   return field as NarrowField<T>;
+ * }
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```typescript
+ * const fields = [
+ *   { type: 'input', key: 'name', value: '', props: { type: 'text' } },
+ *   { type: 'select', key: 'country', value: 'us', options: [...] },
+ * ] as const satisfies NarrowFields;
+ * ```
+ */
+type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
 
 /**
  * Helper type to convert union to intersection
@@ -664,27 +715,49 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * 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.
+ * This prevents `as const` from over-narrowing types like `''` to literal `''` instead of `string`.
+ *
+ * @example
+ * ```typescript
+ * type A = Widen<''>; // string
+ * type B = Widen<false>; // boolean
+ * type C = Widen<42>; // number
+ * type D = Widen<string[]>; // string[]
+ * ```
+ */
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+/**
+ * Infer value type based on field type and props.
+ * - Slider fields: always number
+ * - Input fields with props.type: 'number': number
+ * - Other fields: widen the literal value type
+ */
+type InferValueType<T, V> = T extends {
+    type: 'slider';
+} ? number : T extends {
+    type: 'input';
+    props: {
+        type: 'number';
+    };
+} ? number : Widen<V>;
+/** Make type optional if field is not required */
+type MaybeOptional<T, V> = T extends {
+    required: true;
+} ? V : V | undefined;
 /**
  * Process a single field and determine its contribution to the form value type
- * Handles:
- * - Page fields: flatten children (valueHandling: 'flatten')
- * - Row fields: flatten children (valueHandling: 'flatten')
- * - Group fields: nest children under group key (valueHandling: 'include')
- * - Text fields: exclude from values (valueHandling: 'exclude')
- * - Value fields: include with their key and value type
  */
 type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string, unknown> : T extends {
-    type: 'page';
-    fields: infer TFields;
-} ? TFields extends RegisteredFieldTypes[] ? InferFormValueWithDepth<TFields, Depth[D]> : never : T extends {
-    type: 'row';
-    fields: infer TFields;
-} ? TFields extends RegisteredFieldTypes[] ? InferFormValueWithDepth<TFields, Depth[D]> : never : 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 TFields;
-} ? K extends string ? TFields extends RegisteredFieldTypes[] ? {
-    [P in K]: InferFormValueWithDepth<TFields, Depth[D]>;
+    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 {
@@ -692,39 +765,46 @@ type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string
 } ? never : T extends {
     key: infer K;
     value: infer V;
-    required: true;
-} ? K extends string ? {
-    [P in K]: V;
-} : never : T extends {
-    key: infer K;
-    value: infer V;
 } ? K extends string ? {
-    [P in K]: V | undefined;
+    [P in K]: MaybeOptional<T, InferValueType<T, V>>;
 } : never : never;
 /**
  * Internal helper with depth tracking
  */
 type InferFormValueWithDepth<T extends RegisteredFieldTypes[], D extends number = 5> = UnionToIntersection<ProcessField<T[number], D>>;
 /**
- * Infer form value type from an array of field definitions
- * Recursively processes nested structures and merges the results
- * Limited to 5 levels of nesting to prevent infinite type instantiation
+ * 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.
  *
  * @example
  * ```typescript
+ * // From fields array
  * const fields = [
  *   { type: 'input', key: 'email', value: '', required: true },
- *   { type: 'group', key: 'address', fields: [
- *     { type: 'input', key: 'street', value: '' },
- *     { type: 'input', key: 'city', value: '' }
- *   ]}
+ *   { type: 'input', key: 'name', value: '' }
  * ] as const;
+ * type FieldsValue = InferFormValue<typeof fields>;
+ *
+ * // From FormConfig
+ * const config = {
+ *   fields: [
+ *     { type: 'input', key: 'email', value: '', required: true },
+ *     { type: 'input', key: 'name', value: '' }
+ *   ]
+ * } as const satisfies FormConfig;
+ * type ConfigValue = InferFormValue<typeof config>;
  *
- * type FormValue = InferFormValue<typeof fields>;
- * // Result: { email: string; address: { street?: string; city?: string } }
+ * // Result: { email: string; name?: string }
  * ```
  */
-type InferFormValue$1<T extends RegisteredFieldTypes[]> = InferFormValueWithDepth<T, 5>;
+type InferFormValue$1<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<ExtractFields<T> extends RegisteredFieldTypes[] ? ExtractFields<T> : [...ExtractFields<T>], 5> : never;
 
 /**
  * Base configuration shared by all validators
@@ -1290,19 +1370,18 @@ interface SubmissionConfig<TValue = unknown> {
  *
  * @example
  * ```typescript
- * const formConfig: FormConfig = {
+ * const formConfig = {
  *   fields: [
- *     { type: 'input', key: 'email', value: '', label: 'Email', required: true, email: true },
+ *     { type: 'input', key: 'email', value: '', label: 'Email', required: true },
  *     { type: 'group', key: 'address', label: 'Address', fields: [
  *       { type: 'input', key: 'street', value: '', label: 'Street' },
  *       { type: 'input', key: 'city', value: '', label: 'City' }
  *     ]},
- *     { type: 'button', key: 'submit', label: 'Submit', buttonType: 'submit' }
  *   ],
- *   schemas: [
- *     { name: 'emailSchema', schema: { email: validators.email } }
- *   ]
- * };
+ * } as const satisfies FormConfig;
+ *
+ * // Infer form value type from config
+ * type FormValue = InferFormValue<typeof formConfig>;
  * ```
  *
  * @typeParam TFields - Array of registered field types available for this form
@@ -1310,7 +1389,7 @@ interface SubmissionConfig<TValue = unknown> {
  *
  * @public
  */
-interface FormConfig<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields>> {
+interface FormConfig<TFields extends NarrowFields | RegisteredFieldTypes[] = RegisteredFieldTypes[], TValue = InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>> {
     /**
      * Array of field definitions that define the form structure.
      *
@@ -2151,11 +2230,6 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     readonly disabled: Signal<boolean>;
     /** Whether the form is currently submitting. */
     readonly submitting: Signal<boolean>;
-    /**
-     * Announcement message for screen readers.
-     * Updates when form submission fails due to validation errors.
-     */
-    readonly errorAnnouncement: _angular_core.WritableSignal<string>;
     readonly initialized$: rxjs.Observable<boolean>;
     /** Emits when form validity changes. */
     readonly validityChange: _angular_core.OutputRef<boolean>;
@@ -2182,18 +2256,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Emits when page navigation state changes (canGoNext, canGoPrevious, etc.). */
     readonly onPageNavigationStateChange: _angular_core.OutputRef<PageNavigationStateChangeEvent>;
     protected readonly resolvedFields: Signal<ResolvedField[]>;
-    private readonly syncEntityToValue;
-    private readonly clearErrorsOnConfigChange;
-    private readonly emitPagedFormInitialized;
-    private readonly emitNonPagedFormInitialized;
-    private readonly handleFormReset;
-    private readonly handleFormClear;
-    /**
-     * Announces form validation errors to screen readers when submission is attempted
-     * on an invalid form.
-     */
-    private readonly handleErrorAnnouncement;
-    private readonly handleSubmission;
+    constructor();
     /**
      * Handles native form submission triggered by:
      * - Pressing Enter in an input field
@@ -2206,16 +2269,13 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
      * @param event - The native submit event from the form element
      */
     protected onNativeSubmit(event: Event): void;
+    private setupEffects;
+    private setupEventHandlers;
     private registerValidatorsFromConfig;
     private createFormSetupFromConfig;
     private createEmptyFormSetup;
     private onFormReset;
     private onFormClear;
-    /**
-     * Counts the total number of validation errors across all fields.
-     * Used for screen reader announcements.
-     */
-    private countErrors;
     ngOnDestroy(): void;
     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>;
@@ -2528,51 +2588,48 @@ interface InputProps<T extends InputType = InputType> {
     type?: T;
     placeholder?: DynamicText;
 }
+/**
+ * Input types that produce string values
+ */
+type StringInputType = Exclude<InputType, 'number'>;
 /**
  * Number input field with strict number value type.
  * When props.type is 'number', value must be number.
+ * Props is REQUIRED and must include type: 'number'.
  */
 interface NumberInputField<TProps extends {
     type?: string;
-} = {
+} = InputProps> extends BaseValueField<TProps & {
     type: 'number';
-    placeholder?: DynamicText;
-}> extends BaseValueField<TProps, number> {
+}, number> {
     type: 'input';
-    props?: TProps;
+    props: TProps & {
+        type: 'number';
+    };
 }
 /**
  * String input field with strict string value type.
- * When props.type is text/email/etc, value must be string.
+ * When props.type is text/email/etc (or undefined), value must be string.
+ * Props type cannot be 'number'.
  */
 interface StringInputField<TProps extends {
     type?: string;
-} = {
-    type: 'text' | 'email' | 'password' | 'tel' | 'url';
-    placeholder?: DynamicText;
-}> extends BaseValueField<TProps, string> {
-    type: 'input';
-    props?: TProps;
-}
-/**
- * Helper type to extract the input type from props
- */
-type ExtractInputType<TProps> = TProps extends {
-    type?: infer T;
-} ? T : InputType;
-/**
- * Fallback variant when props is undefined - allows both string and number values
- */
-interface UndefinedPropsInputField extends BaseValueField<undefined, string | number> {
+} = InputProps> extends BaseValueField<TProps & {
+    type?: StringInputType;
+}, string> {
     type: 'input';
-    props?: never;
+    props?: TProps & {
+        type?: StringInputType;
+    };
 }
 /**
- * Builds discriminated union based on what input types are possible in TProps
+ * Builds discriminated union where props.type determines value type.
+ * - If props.type is 'number', only NumberInputField matches (value: number)
+ * - If props.type is undefined/text/email/etc, only StringInputField matches (value: string)
  */
 type BuildInputFieldUnion<TProps extends {
     type?: string;
-}> = (ExtractInputType<TProps> extends infer T ? T extends string ? ('number' extends T ? NumberInputField<TProps> : never) | (Exclude<T, 'number'> extends never ? never : StringInputField<TProps>) : StringInputField<TProps> : never) | UndefinedPropsInputField;
+}> = NumberInputField<TProps> | StringInputField<TProps>;
 /**
  * Input field with automatic type-safe value inference.
  * TypeScript automatically infers the correct value type based on props.type.
@@ -3104,62 +3161,26 @@ interface ResolvedError {
  */
 declare function createResolvedErrorsSignal<T>(field: Signal<FieldTree<T>>, validationMessages: Signal<ValidationMessages | undefined>, defaultValidationMessages?: Signal<ValidationMessages | undefined>, injector?: Injector): Signal<ResolvedError[]>;
 
-/**
- * Internal Angular Signal Forms structure interface.
- *
- * WARNING: These properties are internal Angular APIs and may change between versions.
- * This interface documents our dependency on Angular internals for form structure access.
- *
- * Used to access:
- * - `structure.childrenMap()` - Map of child field keys to their FieldTree instances
- * - `fieldProxy` - The FieldTree proxy for a FieldNode
- */
+interface ChildData {
+    reader: FieldTree<unknown>;
+}
+interface ChildrenData {
+    byPropertyKey: Map<string, ChildData>;
+}
 interface FormInternals<T = unknown> {
-    /**
-     * Internal structure containing form graph information.
-     * Present on forms created via `form()` function.
-     */
-    structure?: {
-        /**
-         * Returns a Map of child field keys to their FieldTree instances.
-         * Keys are strings for object properties or stringified indices for arrays.
-         */
-        childrenMap?: () => Map<string, FieldTree<unknown>>;
+    structure: {
+        childrenMap: () => ChildrenData;
     };
-    /**
-     * The FieldTree proxy for navigating the form graph.
-     * Present on FieldNode instances.
-     */
     fieldProxy?: FieldTree<T>;
 }
+type FormInput = FormInternals | Signal<FormInternals> | unknown;
 /**
- * Type guard for checking if a form-like object has the internal structure property.
- *
- * @param form - The form object to check
- * @returns True if the form has a structure property with childrenMap
- */
-declare function hasFormStructure(form: unknown): form is FormInternals;
-/**
- * Safely retrieves the childrenMap from a form's internal structure.
- *
- * @param form - The form object (from `form()` function or FieldTree)
- * @returns The childrenMap or null if not available
- */
-declare function getChildrenMap(form: unknown): Map<string, FieldTree<unknown>> | null;
-/**
- * Safely retrieves the fieldProxy from a form node.
- *
- * @param node - The form node (FieldNode or similar)
- * @returns The fieldProxy FieldTree or null if not available
+ * Type guard that unwraps signals and checks for FormInternals structure.
+ * Use this when the input might be a signal wrapping FormInternals.
  */
+declare function hasFormStructure(form: FormInput): form is FormInternals | Signal<FormInternals>;
+declare function getChildrenMap(form: FormInput): Map<string, FieldTree<unknown>> | null;
 declare function getFieldProxy<T = unknown>(node: unknown): FieldTree<T> | null;
-/**
- * Retrieves a child FieldTree from a form by key.
- *
- * @param form - The parent form
- * @param key - The child field key
- * @returns The child FieldTree or null if not found
- */
 declare function getChildFieldTree(form: unknown, key: string): FieldTree<unknown> | null;
 
 /**
@@ -3216,7 +3237,8 @@ declare class RowFieldComponent {
     private readonly rawFieldRegistry;
     private readonly fieldsSource;
     protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
-    private readonly emitInitializedOnFieldsResolved;
+    constructor();
+    private setupEffects;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowFieldComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowFieldComponent, "div[row-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -3263,7 +3285,8 @@ declare class GroupFieldComponent<TModel = Record<string, unknown>> {
     readonly submitted: _angular_core.OutputRef<SubmitEvent>;
     private readonly fieldsSource;
     protected readonly resolvedFields: _angular_core.Signal<ResolvedField[]>;
-    private readonly emitInitializedOnFieldsResolved;
+    constructor();
+    private setupEffects;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupFieldComponent<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupFieldComponent<any>, "fieldset[group-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, { "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; }, never, never, true, never>;
 }
@@ -3306,9 +3329,9 @@ declare class ArrayFieldComponent<TModel = Record<string, unknown>> {
     private readonly updateVersion;
     private readonly itemOrderSignal;
     readonly resolvedItems: _angular_core.WritableSignal<ResolvedArrayItem[]>;
-    private readonly syncFieldsOnArrayChange;
-    private readonly handleAddItem;
-    private readonly handleRemoveItem;
+    constructor();
+    private setupEffects;
+    private setupEventHandlers;
     private performDifferentialUpdate;
     private resolveAllItems;
     private appendItems;
@@ -3459,4 +3482,4 @@ declare function injectFieldRegistry(): {
 };
 
 export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, DynamicForm, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FormClearEvent, FormResetEvent, GroupFieldComponent, NextPageEvent, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RowFieldComponent, SubmitEvent, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, checkboxFieldMapper, createResolvedErrorsSignal, datepickerFieldMapper, dynamicTextToObservable, getChildFieldTree, getChildrenMap, getFieldProxy, getFieldValueHandling, groupFieldMapper, hasFormStructure, injectFieldRegistry, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, optionsFieldMapper, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, shouldShowErrors, valueFieldMapper };
-export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonField, ButtonLogicContext, CheckboxField, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DatepickerField, DatepickerProps, DynamicFormFieldRegistry, DynamicText, EvaluationContext, EventArgs, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormInternals, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, InputField, InputProps, LeafFieldTypes, LogicConfig, MapperFn, MultiCheckboxField, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RadioField, RegisteredFieldTypes, ResolvedError, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SelectField, SelectProps, SliderField, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TextareaField, TextareaProps, ToggleField, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };
+export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonField, ButtonLogicContext, CheckboxField, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DatepickerField, DatepickerProps, DynamicFormFieldRegistry, DynamicText, EvaluationContext, EventArgs, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormInternals, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, InputField, InputProps, LeafFieldTypes, LogicConfig, MapperFn, MultiCheckboxField, NarrowField, NarrowFields, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RadioField, RegisteredFieldTypes, ResolvedError, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SelectField, SelectProps, SliderField, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TextareaField, TextareaProps, ToggleField, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };