@ng-forge/dynamic-forms 0.1.3 → 0.3.0

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

@@ -1,5 +1,6 @@
-import { FormEvent, FieldDef, FormEventConstructor, BaseCheckedField, BaseValueField, DynamicText, FieldOption, ValidationMessages } from '@ng-forge/dynamic-forms';
-import { Signal, Injector } from '@angular/core';
+import { FormEvent, FieldDef, FormEventConstructor, BaseCheckedField, BaseValueField, DynamicText, FieldMeta, FieldOption, ValidationMessages } from '@ng-forge/dynamic-forms';
+import * as i0 from '@angular/core';
+import { Signal, Injector, ElementRef, PipeTransform } from '@angular/core';
 import { FieldTree } from '@angular/forms/signals';
 
 /**
@@ -42,6 +43,94 @@ interface DatepickerField<TProps> extends BaseValueField<TProps, Date | string>
     startAt?: Date | null;
 }
 
+/**
+ * Autocomplete values for HTML input elements.
+ * Based on the WHATWG HTML specification for autofill.
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill
+ */
+type AutocompleteValue = 'off' | 'on' | 'name' | 'honorific-prefix' | 'given-name' | 'additional-name' | 'family-name' | 'honorific-suffix' | 'nickname' | 'email' | 'username' | 'new-password' | 'current-password' | 'one-time-code' | 'organization-title' | 'organization' | 'street-address' | 'address-line1' | 'address-line2' | 'address-line3' | 'address-level4' | 'address-level3' | 'address-level2' | 'address-level1' | 'country' | 'country-name' | 'postal-code' | 'cc-name' | 'cc-given-name' | 'cc-additional-name' | 'cc-family-name' | 'cc-number' | 'cc-exp' | 'cc-exp-month' | 'cc-exp-year' | 'cc-csc' | 'cc-type' | 'transaction-currency' | 'transaction-amount' | 'language' | 'bday' | 'bday-day' | 'bday-month' | 'bday-year' | 'sex' | 'tel' | 'tel-country-code' | 'tel-national' | 'tel-area-code' | 'tel-local' | 'tel-extension' | 'impp' | 'url' | 'photo';
+/**
+ * Input mode hints for virtual keyboards on mobile devices.
+ *
+ * @see https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute
+ */
+type InputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+/**
+ * Enter key hints for virtual keyboards.
+ *
+ * @see https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-enterkeyhint-attribute
+ */
+type EnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+/**
+ * Autocapitalization hints for virtual keyboards.
+ *
+ * @see https://html.spec.whatwg.org/multipage/interaction.html#attr-autocapitalize
+ */
+type Autocapitalize = 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+/**
+ * Meta attributes specific to HTML input elements.
+ *
+ * Extends FieldMeta with input-specific native attributes that can be passed through
+ * to the underlying input element.
+ *
+ * @example
+ * ```typescript
+ * // Input field with meta attributes
+ * {
+ *   type: 'input',
+ *   key: 'email',
+ *   meta: {
+ *     autocomplete: 'email',
+ *     inputmode: 'email',
+ *     enterkeyhint: 'next',
+ *     spellcheck: false,
+ *     'data-testid': 'email-input'
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+interface InputMeta extends FieldMeta {
+    /**
+     * Hint for form autofill behavior.
+     */
+    autocomplete?: AutocompleteValue;
+    /**
+     * Hint for virtual keyboard type on mobile devices.
+     */
+    inputmode?: InputMode;
+    /**
+     * Hint for the enter key label on virtual keyboards.
+     */
+    enterkeyhint?: EnterKeyHint;
+    /**
+     * Whether to enable spellchecking for the input.
+     */
+    spellcheck?: boolean;
+    /**
+     * Hint for autocapitalization behavior on virtual keyboards.
+     */
+    autocapitalize?: Autocapitalize;
+    /**
+     * Pattern for client-side validation (regex).
+     */
+    pattern?: string;
+    /**
+     * Size hint for the input element (character count).
+     */
+    size?: number;
+    /**
+     * Maximum number of characters allowed.
+     */
+    maxlength?: number;
+    /**
+     * Minimum number of characters required.
+     */
+    minlength?: number;
+}
+
 /**
  * HTML input types supported by input fields
  */
@@ -76,7 +165,7 @@ interface NumberInputField<TProps extends {
     type?: string;
 } = InputProps> extends BaseValueField<TProps & {
     type: 'number';
-}, number> {
+}, number, InputMeta> {
     type: 'input';
     props: TProps & {
         type: 'number';
@@ -91,7 +180,7 @@ interface StringInputField<TProps extends {
     type?: string;
 } = InputProps> extends BaseValueField<TProps & {
     type?: StringInputType;
-}, string> {
+}, string, InputMeta> {
     type: 'input';
     props?: TProps & {
         type?: StringInputType;
@@ -155,12 +244,12 @@ type InputField<TProps extends {
  */
 interface MultiCheckboxField<TValue, TProps = object> extends BaseValueField<TProps, TValue[]> {
     type: 'multi-checkbox';
-    options: FieldOption<TValue>[];
+    readonly options: readonly FieldOption<TValue>[];
 }
 
 interface RadioField<T, TProps> extends BaseValueField<TProps, T> {
     type: 'radio';
-    options: FieldOption<T>[];
+    readonly options: readonly FieldOption<T>[];
 }
 
 interface SelectProps {
@@ -178,12 +267,75 @@ interface SliderField<TProps> extends BaseValueField<TProps, number> {
     step?: number;
 }
 
+/**
+ * Text wrapping behavior for textarea elements.
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-elements.html#attr-textarea-wrap
+ */
+type TextareaWrap = 'hard' | 'soft' | 'off';
+/**
+ * Meta attributes specific to HTML textarea elements.
+ *
+ * Extends FieldMeta with textarea-specific native attributes that can be passed through
+ * to the underlying textarea element.
+ *
+ * @example
+ * ```typescript
+ * // Textarea field with meta attributes
+ * {
+ *   type: 'textarea',
+ *   key: 'description',
+ *   meta: {
+ *     wrap: 'soft',
+ *     spellcheck: true,
+ *     autocomplete: 'off',
+ *     'data-testid': 'description-textarea'
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+interface TextareaMeta extends FieldMeta {
+    /**
+     * How text should wrap when submitted.
+     * - 'hard': Line breaks are inserted to wrap text at cols width
+     * - 'soft': Text is wrapped for display but not in submitted value
+     * - 'off': No wrapping, horizontal scrolling if needed
+     */
+    wrap?: TextareaWrap;
+    /**
+     * Whether to enable spellchecking for the textarea.
+     */
+    spellcheck?: boolean;
+    /**
+     * Hint for form autofill behavior.
+     */
+    autocomplete?: AutocompleteValue;
+    /**
+     * Hint for autocapitalization behavior on virtual keyboards.
+     */
+    autocapitalize?: Autocapitalize;
+    /**
+     * Hint for the enter key label on virtual keyboards.
+     */
+    enterkeyhint?: EnterKeyHint;
+    /**
+     * Maximum number of characters allowed.
+     */
+    maxlength?: number;
+    /**
+     * Minimum number of characters required.
+     */
+    minlength?: number;
+}
+
 interface TextareaProps {
     placeholder?: DynamicText;
     rows?: number;
     cols?: number | undefined;
 }
-interface TextareaField<TProps = TextareaProps> extends BaseValueField<TProps, string> {
+interface TextareaField<TProps = TextareaProps> extends BaseValueField<TProps, string, TextareaMeta> {
     type: 'textarea';
     maxLength?: number | undefined;
 }
@@ -311,5 +463,81 @@ declare function createResolvedErrorsSignal<T>(field: Signal<FieldTree<T>>, vali
  */
 declare function shouldShowErrors<T>(field: Signal<FieldTree<T>>): Signal<boolean>;
 
-export { buildValueFieldInputs, checkboxFieldMapper, createResolvedErrorsSignal, datepickerFieldMapper, optionsFieldMapper, resolveValueFieldContext, shouldShowErrors, valueFieldMapper };
-export type { ButtonField, CheckboxField, DatepickerField, DatepickerProps, EventArgs, FieldWithOptions, InputField, InputProps, InputType, InputTypeToValueType, MultiCheckboxField, RadioField, ResolvedError, SelectField, SelectProps, SliderField, StringInputType, TextareaField, TextareaProps, ToggleField, ValueFieldContext };
+/**
+ * Performs a deep equality comparison between two values
+ */
+declare function isEqual(a: unknown, b: unknown): boolean;
+
+/**
+ * Configuration options for setupMetaTracking.
+ */
+interface MetaTrackingOptions {
+    /**
+     * CSS selector for target elements within the host.
+     * If not provided, meta attributes are applied directly to the host element.
+     *
+     * @example
+     * // Apply to internal radio inputs
+     * selector: 'input[type="radio"]'
+     *
+     * // Apply to host element (for Shadow DOM components)
+     * selector: undefined
+     */
+    selector?: string;
+    /**
+     * Additional signals to track that should trigger re-application of meta.
+     * Useful for components where DOM elements are dynamically created (e.g., radio options).
+     *
+     * @example
+     * // Re-apply when options change
+     * dependents: [this.options]
+     */
+    dependents?: Signal<unknown>[];
+}
+/**
+ * Sets up automatic meta attribute tracking and application for wrapped components.
+ *
+ * This utility creates an `afterRenderEffect` that applies meta attributes to DOM elements
+ * after Angular's render cycle. It efficiently tracks signal dependencies and only re-applies
+ * when the meta signal or any dependent signals change.
+ *
+ * Use this instead of MutationObserver for better performance and integration with Angular's
+ * change detection.
+ *
+ * @param elementRef - Reference to the host element
+ * @param meta - Signal containing meta attributes to apply
+ * @param options - Configuration options
+ *
+ * @example
+ * ```typescript
+ * // For a radio group with dynamic options
+ * constructor() {
+ *   setupMetaTracking(inject(ElementRef), this.meta, {
+ *     selector: 'input[type="radio"]',
+ *     dependents: [this.options]
+ *   });
+ * }
+ *
+ * // For a simple checkbox
+ * constructor() {
+ *   setupMetaTracking(inject(ElementRef), this.meta, {
+ *     selector: 'input[type="checkbox"]'
+ *   });
+ * }
+ *
+ * // For Shadow DOM components (apply to host)
+ * constructor() {
+ *   setupMetaTracking(inject(ElementRef), this.meta);
+ * }
+ * ```
+ */
+declare function setupMetaTracking(elementRef: ElementRef<HTMLElement>, meta: Signal<FieldMeta | undefined>, options?: MetaTrackingOptions): void;
+
+declare class ValueInArrayPipe implements PipeTransform {
+    transform<T>(element: T, array: T[] | undefined): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValueInArrayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ValueInArrayPipe, "inArray", true>;
+}
+
+export { ValueInArrayPipe, buildValueFieldInputs, checkboxFieldMapper, createResolvedErrorsSignal, datepickerFieldMapper, isEqual, optionsFieldMapper, resolveValueFieldContext, setupMetaTracking, shouldShowErrors, valueFieldMapper };
+export type { Autocapitalize, AutocompleteValue, ButtonField, CheckboxField, DatepickerField, DatepickerProps, EnterKeyHint, EventArgs, FieldWithOptions, InputField, InputMeta, InputMode, InputProps, InputType, InputTypeToValueType, MetaTrackingOptions, MultiCheckboxField, RadioField, ResolvedError, SelectField, SelectProps, SliderField, StringInputType, TextareaField, TextareaMeta, TextareaProps, TextareaWrap, ToggleField, ValueFieldContext };

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

@@ -1,9 +1,9 @@
+import * as _angular_core from '@angular/core';
+import { Provider, Injector, WritableSignal, Type } from '@angular/core';
 import { Mock } from 'vitest';
-import { DynamicFormLogger, FieldDef, FormConfig, DynamicForm, ValidationMessages, FieldSignalContext } from '@ng-forge/dynamic-forms';
+import { Logger, FieldDef, FormConfig, DynamicForm, ValidationMessages, FieldSignalContext, RegisteredFieldTypes } from '@ng-forge/dynamic-forms';
 import { ComponentFixture } from '@angular/core/testing';
 import { ValidationError, form, FieldTree } from '@angular/forms/signals';
-import * as _angular_core from '@angular/core';
-import { Injector, WritableSignal, Type } from '@angular/core';
 import { Observable } from 'rxjs';
 
 /**
@@ -31,7 +31,7 @@ declare function delay(ms?: number): Promise<void>;
 /**
  * Mock logger with vitest spies for testing.
  */
-interface MockLogger extends DynamicFormLogger {
+interface MockLogger extends Logger {
     debug: Mock;
     info: Mock;
     warn: Mock;
@@ -43,10 +43,10 @@ interface MockLogger extends DynamicFormLogger {
  */
 declare function createMockLogger(): MockLogger;
 /**
- * Creates a silent logger that doesn't output anything.
- * Useful for tests where logging output is not relevant.
+ * Provider for a console logger in tests.
+ * Add this to TestBed.configureTestingModule providers when not using provideDynamicForm().
  */
-declare function createSilentLogger(): DynamicFormLogger;
+declare function provideTestLogger(): Provider;
 
 /**
  * Configuration for creating a dynamic form test
@@ -68,7 +68,7 @@ interface DynamicFormTestResult {
  */
 declare class FormConfigBuilder {
     private fields;
-    field(field: FieldDef<any>): FormConfigBuilder;
+    field(field: FieldDef<unknown>): FormConfigBuilder;
     inputField(key: string, props?: Record<string, unknown>): FormConfigBuilder;
     requiredInputField(key: string, props?: Record<string, unknown>): FormConfigBuilder;
     selectField(key: string, options: Array<{
@@ -76,10 +76,10 @@ declare class FormConfigBuilder {
         label: string;
     }>, props?: Record<string, unknown>): FormConfigBuilder;
     checkboxField(key: string, props?: Record<string, unknown>): FormConfigBuilder;
-    rowField(key: string, fields: FieldDef<any>[]): FormConfigBuilder;
-    groupField(key: string, fields: FieldDef<any>[]): FormConfigBuilder;
+    rowField(key: string, fields: FieldDef<unknown>[]): FormConfigBuilder;
+    groupField(key: string, fields: FieldDef<unknown>[]): FormConfigBuilder;
     buttonField(key: string, props?: Record<string, unknown>): FormConfigBuilder;
-    pageField(key: string, fields: FieldDef<any>[], title?: string): FormConfigBuilder;
+    pageField(key: string, fields: FieldDef<unknown>[], title?: string): FormConfigBuilder;
     build(): FormConfig;
 }
 /**
@@ -257,7 +257,7 @@ declare function createTestFieldContext<TModel extends Record<string, unknown> =
  * Simple form configuration interface for testing
  */
 interface TestFormConfig$1 {
-    fields: FieldDef<any>[];
+    fields: FieldDef<unknown>[];
 }
 /**
  * Configuration for creating a dynamic form test
@@ -267,18 +267,19 @@ interface SimpleTestConfig<T = Record<string, unknown>> {
     initialValue?: T;
 }
 /**
- * Result of creating a dynamic form test
+ * Result of creating a dynamic form test.
+ * Uses the base DynamicForm type without generic constraints for flexibility in tests.
  */
 interface SimpleTestResult {
-    component: any;
-    fixture: any;
+    component: DynamicForm<RegisteredFieldTypes[]>;
+    fixture: ComponentFixture<DynamicForm<RegisteredFieldTypes[]>>;
 }
 /**
  * Fluent API for building form configurations using existing field structure
  */
 declare class TestFormConfigBuilder<T = Record<string, unknown>> {
     private fields;
-    field(field: FieldDef<any>): TestFormConfigBuilder<T>;
+    field(field: FieldDef<unknown>): TestFormConfigBuilder<T>;
     inputField(key: string, props?: Record<string, unknown>): TestFormConfigBuilder<T>;
     requiredInputField(key: string, props?: Record<string, unknown>): TestFormConfigBuilder<T>;
     checkboxField(key: string, props?: Record<string, unknown>): TestFormConfigBuilder<T>;
@@ -299,58 +300,58 @@ declare class SimpleTestUtils {
     /**
      * Waits for the dynamic form to initialize
      */
-    static waitForInit(fixture: any): Promise<void>;
+    static waitForInit(fixture: ComponentFixture<DynamicForm>): Promise<void>;
     /**
      * Simulates user input on a field element
      */
-    static simulateInput(fixture: any, selector: string, value: string): Promise<void>;
+    static simulateInput(fixture: ComponentFixture<DynamicForm>, selector: string, value: string): Promise<void>;
     /**
      * Simulates checkbox toggle
      */
-    static simulateCheckbox(fixture: any, selector: string, checked: boolean): Promise<void>;
+    static simulateCheckbox(fixture: ComponentFixture<DynamicForm>, selector: string, checked: boolean): Promise<void>;
     /**
      * Gets the current form value from the component
      */
-    static getFormValue(component: any): Record<string, unknown> | undefined;
+    static getFormValue(component: DynamicForm): Record<string, unknown> | undefined;
     /**
      * Checks if the form is valid
      */
-    static isFormValid(component: any): boolean;
+    static isFormValid(component: DynamicForm): boolean;
     /**
      * Asserts that the form has a specific value
      */
-    static assertFormValue(component: any, expectedValue: Record<string, unknown>): void;
+    static assertFormValue(component: DynamicForm, expectedValue: Record<string, unknown>): void;
 }
 declare class TestFieldComponent {
-    value: _angular_core.WritableSignal<string>;
+    field: _angular_core.InputSignal<unknown>;
     key: _angular_core.InputSignal<string>;
     label: _angular_core.InputSignal<string>;
     className: _angular_core.InputSignal<string>;
     tabIndex: _angular_core.InputSignal<number | undefined>;
     props: _angular_core.InputSignal<Record<string, unknown> | undefined>;
     placeholder: _angular_core.InputSignal<string>;
-    fields: _angular_core.InputSignal<unknown[]>;
     arrayContext: _angular_core.InputSignal<unknown>;
+    fields: _angular_core.InputSignal<unknown[]>;
     validationMessages: _angular_core.InputSignal<Record<string, string> | undefined>;
     defaultValidationMessages: _angular_core.InputSignal<Record<string, string> | undefined>;
-    field: _angular_core.InputSignal<unknown>;
+    value: _angular_core.WritableSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TestFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TestFieldComponent, "df-test-field", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "arrayContext": { "alias": "arrayContext"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TestFieldComponent, "df-test-field", never, { "field": { "alias": "field"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "arrayContext": { "alias": "arrayContext"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /**
  * Configuration for setting up a simple component test
  */
-interface SimpleComponentTestConfig<T = any> {
-    field: FieldDef<any>;
+interface SimpleComponentTestConfig<T = unknown> {
+    field: FieldDef<unknown>;
     value?: T;
     pageIndex?: number;
     isVisible?: boolean;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
  * Result of setting up a simple component test
  */
-interface SimpleComponentTestResult<T = any> {
+interface SimpleComponentTestResult<T = unknown> {
     component: T;
     fixture: ComponentFixture<T>;
 }
@@ -361,13 +362,13 @@ declare function setupSimpleTest<T>(componentType: Type<T>, config: SimpleCompon
 /**
  * Creates a simple test field definition
  */
-declare function createSimpleTestField(key: string, label: string): FieldDef<any>;
+declare function createSimpleTestField(key: string, label: string): FieldDef<unknown>;
 
 /**
  * Simple form configuration interface for testing
  */
 interface TestFormConfig {
-    fields: FieldDef<any>[];
+    fields: FieldDef<unknown>[];
 }
 /**
  * Unified configuration for creating dynamic form tests
@@ -390,7 +391,7 @@ interface TestResult<T = unknown> {
  * Configuration for setting up individual field component tests
  */
 interface ComponentTestConfig<T = unknown> {
-    field: FieldDef<any>;
+    field: FieldDef<unknown>;
     value?: T;
 }
 /**
@@ -401,6 +402,37 @@ interface ComponentTestResult<T = unknown> {
     fixture: ComponentFixture<T>;
 }
 
+/**
+ * Type utilities for exhaustive whitelist type testing.
+ *
+ * These utilities help ensure that type definitions remain stable by detecting
+ * when properties are added, removed, or changed.
+ */
+/**
+ * Extracts only the required keys from a type.
+ *
+ * @example
+ * ```typescript
+ * interface Example { a: string; b?: number; }
+ * type Required = RequiredKeys<Example>; // 'a'
+ * ```
+ */
+type RequiredKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? never : K;
+}[keyof T];
+/**
+ * Extracts only the optional keys from a type.
+ *
+ * @example
+ * ```typescript
+ * interface Example { a: string; b?: number; }
+ * type Optional = OptionalKeys<Example>; // 'b'
+ * ```
+ */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+}[keyof T];
+
 declare class TestInputHarness {
     readonly field: _angular_core.InputSignal<FieldTree<string>>;
     readonly key: _angular_core.InputSignal<string>;
@@ -561,5 +593,5 @@ declare const SPANISH_TEST_TRANSLATIONS: {
  */
 declare function createTestTranslationService(initialTranslations?: Record<string, string>): FakeTranslationService;
 
-export { DEFAULT_TEST_TRANSLATIONS, DynamicFormTestUtils, FakeTranslationService, FormConfigBuilder, SPANISH_TEST_TRANSLATIONS, TestFormConfigBuilder as SimpleFormConfigBuilder, SimpleTestUtils, TestCheckboxHarness as TestCheckboxHarnessComponent, TestFieldComponent, TestInputHarness as TestInputHarnessComponent, TestSelectHarness as TestSelectHarnessComponent, createMockLogger, createSilentLogger, createSimpleTestField, createTestFieldContext, createTestFormInjector, createTestTranslationService, delay, setupSimpleTest, testMapper };
-export type { ComponentTestConfig, ComponentTestResult, DynamicFormTestConfig, DynamicFormTestResult, MockLogger, SimpleComponentTestConfig, SimpleComponentTestResult, SimpleTestConfig, SimpleTestResult, TestConfig, TestFieldContextConfig, TestFormConfig, TestResult };
+export { DEFAULT_TEST_TRANSLATIONS, DynamicFormTestUtils, FakeTranslationService, FormConfigBuilder, SPANISH_TEST_TRANSLATIONS, TestFormConfigBuilder as SimpleFormConfigBuilder, SimpleTestUtils, TestCheckboxHarness as TestCheckboxHarnessComponent, TestFieldComponent, TestInputHarness as TestInputHarnessComponent, TestSelectHarness as TestSelectHarnessComponent, createMockLogger, createSimpleTestField, createTestFieldContext, createTestFormInjector, createTestTranslationService, delay, provideTestLogger, setupSimpleTest, testMapper };
+export type { ComponentTestConfig, ComponentTestResult, DynamicFormTestConfig, DynamicFormTestResult, MockLogger, OptionalKeys, RequiredKeys, SimpleComponentTestConfig, SimpleComponentTestResult, SimpleTestConfig, SimpleTestResult, TestConfig, TestFieldContextConfig, TestFormConfig, TestResult };