@digiform/wizard 0.1.7 → 0.2.1

package/features/form-runtime/context/LoaderContext.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+export interface LoaderContextValue {
+    /** Whether the loading process has completed */
+    isLoadingComplete: boolean;
+    /** Signal that loading has completed */
+    setLoadingComplete: (complete: boolean) => void;
+    /** Reset loading state (for re-triggering) */
+    resetLoading: () => void;
+}
+declare const LoaderContext: import('react').Context<LoaderContextValue | null>;
+export interface LoaderProviderProps {
+    children: ReactNode;
+    /** Initial loading complete state (default: false for sections with loaders, true otherwise) */
+    initialComplete?: boolean;
+}
+/**
+ * Provider component for loader state.
+ * Should wrap each FormSection that may contain a Progress Loader.
+ */
+export declare const LoaderProvider: import('react').NamedExoticComponent<LoaderProviderProps>;
+/**
+ * Hook to access loader context.
+ * Returns a fallback value (isLoadingComplete: true) if used outside a provider,
+ * ensuring components show immediately when no loader is present.
+ */
+export declare const useLoaderContext: () => LoaderContextValue;
+/**
+ * Hook to check if we're inside a LoaderProvider
+ */
+export declare const useHasLoaderProvider: () => boolean;
+export { LoaderContext };

package/features/form-runtime/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useComponentTriggers, useFieldTriggerMonitor, } from './useComponentTriggers';

package/features/form-runtime/hooks/useApiActions.d.ts

@@ -0,0 +1,42 @@
+import { ApiCallConfig, FormData } from '../../../../../core/src/index.ts';
+import { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+interface ApiActionHookOptions {
+    config: ApiCallConfig;
+    formData: FormData;
+    onFieldUpdate?: (fieldPath: string, value: unknown) => void;
+}
+interface ApiActionResult {
+    data: unknown;
+    error: Error | null;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    execute: () => void;
+}
+interface ApiGetActionResult extends ApiActionResult {
+    refetch: () => void;
+}
+interface ApiMutateActionResult extends ApiActionResult {
+    mutate: () => void;
+    reset: () => void;
+}
+/**
+ * Hook for executing GET API calls using React Query
+ * Provides automatic caching, error handling, and field mapping for GET requests
+ */
+export declare function useGetApiAction(options: ApiActionHookOptions & {
+    enabled?: boolean;
+}): UseQueryResult<unknown, Error>;
+/**
+ * Hook for executing POST/PUT/PATCH/DELETE API calls using React Query
+ * Provides error handling and field mapping for mutation requests
+ */
+export declare function useMutateApiAction(options: ApiActionHookOptions): UseMutationResult<unknown, Error, void, unknown>;
+/**
+ * Unified hook that automatically chooses between useQuery and useMutation
+ * based on the HTTP method. Provides a consistent API for all HTTP methods.
+ */
+export declare function useApiAction(options: ApiActionHookOptions & {
+    enabled?: boolean;
+}): ApiGetActionResult | ApiMutateActionResult;
+export {};

package/features/form-runtime/hooks/useComponentTriggers.d.ts

@@ -0,0 +1,42 @@
+import { ComponentTrigger } from '../../../../../core/src/index.ts';
+import { ComponentActionExecution, ComponentAlert } from '../../state-management';
+interface ComponentTriggerStateInfo {
+    triggers: ComponentTrigger[];
+    triggerStates: Record<string, unknown>;
+    activeActions: ComponentActionExecution[];
+    alerts: ComponentAlert[];
+}
+interface UseComponentTriggersProps {
+    componentId: string;
+    initialValue?: unknown;
+    onValueChange?: (value: unknown) => void;
+}
+interface UseComponentTriggersReturn {
+    evaluateTriggers: (eventType: "valueChange" | "focus" | "blur", value?: unknown) => void;
+    setOriginalValue: (value: unknown, source?: "initialized" | "api_populated" | "user_reset") => void;
+    alerts: ComponentAlert[];
+    dismissAlert: (alertId?: string) => void;
+    hasTriggers: boolean;
+    hasActions: boolean;
+    triggerState: ComponentTriggerStateInfo;
+    handleValueChange: (value: unknown) => void;
+    handleFocus: () => void;
+    handleBlur: () => void;
+}
+/**
+ * Hook that provides trigger-action system integration for components
+ */
+export declare const useComponentTriggers: ({ componentId, initialValue, onValueChange, }: UseComponentTriggersProps) => UseComponentTriggersReturn;
+/**
+ * Simplified hook for basic field monitoring
+ * Automatically handles value changes and provides isDirty detection
+ */
+export declare const useFieldTriggerMonitor: (componentId: string, initialValue?: unknown) => {
+    onChange: (value: unknown) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    alerts: ComponentAlert[];
+    dismissAlert: (alertId?: string) => void;
+    setOriginalValue: (value: unknown, source?: "initialized" | "api_populated" | "user_reset") => void;
+};
+export {};

package/features/form-runtime/hooks/useComponentVisibility.d.ts

@@ -0,0 +1,13 @@
+import { FormData, VisibilityConditionConfig } from '../../../../../core/src/index.ts';
+interface UseComponentVisibilityProps {
+    visibilityConditions?: VisibilityConditionConfig;
+    formData: FormData;
+}
+interface UseComponentVisibilityReturn {
+    isVisible: boolean;
+    dependencies: string[];
+    /** Whether the step-level loading process has completed */
+    isLoadingComplete: boolean;
+}
+export declare const useComponentVisibility: ({ visibilityConditions, formData, }: UseComponentVisibilityProps) => UseComponentVisibilityReturn;
+export {};

package/features/form-runtime/hooks/useFieldEventHandlers.d.ts

@@ -0,0 +1,14 @@
+import { ComponentValue, FormFieldApi } from '../../../../../core/src/index.ts';
+interface UseFieldEventHandlersProps {
+    componentId: string;
+    hasIsDirtyTriggers: boolean;
+    originalValueFromMachine: ComponentValue;
+    getEnhancedIsDirty: (currentValue: ComponentValue, tanStackIsDirty: boolean) => boolean;
+    resetValidationState: () => void;
+}
+interface UseFieldEventHandlersReturn {
+    handleChange: (field: FormFieldApi) => (value: ComponentValue) => void;
+    handleBlur: (field: FormFieldApi) => () => void;
+}
+export declare const useFieldEventHandlers: ({ componentId, hasIsDirtyTriggers, originalValueFromMachine, getEnhancedIsDirty, resetValidationState, }: UseFieldEventHandlersProps) => UseFieldEventHandlersReturn;
+export {};

package/features/form-runtime/hooks/useFormContext.d.ts

@@ -0,0 +1,4 @@
+declare const FormContext: import('react').Context<any>;
+export declare const FormProvider: import('react').Provider<any>;
+export declare const useFormContext: () => any;
+export { FormContext };

package/features/form-runtime/hooks/useFormFieldState.d.ts

@@ -0,0 +1,13 @@
+import { ComponentValue } from '../../../../../core/src/index.ts';
+interface UseFormFieldStateProps {
+    componentId: string;
+    hasIsDirtyTriggers: boolean;
+}
+interface UseFormFieldStateReturn {
+    originalValueFromMachine: ComponentValue | undefined;
+    initializeField: () => void;
+    handleFormReset: () => void;
+    getEnhancedIsDirty: (currentValue: ComponentValue, tanStackIsDirty: boolean) => boolean;
+}
+export declare const useFormFieldState: ({ componentId, hasIsDirtyTriggers, }: UseFormFieldStateProps) => UseFormFieldStateReturn;
+export {};

package/features/form-runtime/hooks/useValidationEvents.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom hook for handling validation trigger events
+ * Replaces useEffect-based event listening with proper cleanup
+ */
+interface UseValidationEventsProps {
+    componentId: string;
+}
+interface UseValidationEventsReturn {
+    forceShowValidation: boolean;
+    resetValidationState: () => void;
+}
+export declare const useValidationEvents: ({ componentId, }: UseValidationEventsProps) => UseValidationEventsReturn;
+export {};

package/features/form-runtime/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Form Runtime Feature
+ *
+ * Core components and functionality for rendering and executing forms
+ */
+export { default as ComponentAdapterComplete } from './ComponentAdapterComplete/ComponentAdapterComplete';
+export * from './components';
+export * from './config';
+export type { FormWizardProps } from './FormWizard/FormWizard';
+export { default as FormWizard } from './FormWizard/FormWizard';
+export * from './hooks';
+export * from './utils';

package/features/form-runtime/utils/componentDisplayValue.d.ts

@@ -0,0 +1,9 @@
+import { ComponentConfig, ComponentValue } from '../../../../../core/src/index.ts';
+/**
+ * Get the appropriate display value renderer for a component type
+ */
+export declare const getDisplayValueRenderer: (componentType: string) => (component: ComponentConfig, value: ComponentValue) => React.ReactNode;
+/**
+ * Render display value for any component type
+ */
+export declare const renderComponentDisplayValue: (component: ComponentConfig, value: ComponentValue) => React.ReactNode;

package/features/form-runtime/utils/errorUtils.d.ts

@@ -0,0 +1,13 @@
+export declare const parseError: (error: unknown) => string;
+export declare const parseAllErrors: (errors: unknown[]) => string[];
+export declare const getMostRelevantError: (errors: unknown[]) => string;
+export declare const getFirstErrorMessage: (errors: unknown[]) => string;
+export declare const getErrorDebugInfo: (errors: unknown[]) => {
+    index: number;
+    type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    constructor: string | undefined;
+    raw: unknown;
+    parsed: string;
+    validationType: "custom" | "required" | "minLength" | "min" | "max" | "default" | "email" | "maxLength" | "pattern";
+    priority: 4 | 6 | 8 | 1 | 2 | 3 | 5 | 10 | 7;
+}[];

package/features/form-runtime/utils/fieldHelpers.d.ts

@@ -0,0 +1,38 @@
+import { ComponentConfig, ComponentValue, FormFieldApi } from '../../../../../core/src/index.ts';
+/**
+ * Minimal form state interface for validation display state
+ * Contains only the properties used by getValidationDisplayState function
+ */
+interface FormState {
+    isSubmitting: boolean;
+}
+/**
+ * Determines if a component should be registered as a form field with TanStack Form
+ * Display-only components like paragraphs, headings, buttons, etc. should not be form fields
+ */
+export declare const shouldBeFormField: (component: ComponentConfig) => boolean;
+/**
+ * Checks if a component has isDirty triggers configured
+ */
+export declare const checkHasIsDirtyTriggers: (component: ComponentConfig) => boolean;
+/**
+ * Determines if a field has a meaningful value based on component type
+ */
+export declare const checkFieldHasValue: (fieldValue: ComponentValue, componentType: string) => boolean;
+/**
+ * Determines if component should render in display mode
+ */
+export declare const shouldShowDisplayMode: (readOnly: boolean, hasValue: boolean) => boolean;
+/**
+ * Gets validation state for display
+ */
+export declare const getValidationDisplayState: (fieldMeta: FormFieldApi["state"]["meta"], formState: FormState, forceShowValidation: boolean) => {
+    fieldErrors: string[];
+    isInvalid: boolean;
+    isSubmitAttempted: boolean;
+};
+/**
+ * Determines if alerts should be shown based on trigger configuration and state
+ */
+export declare const shouldShowComponentAlerts: (hasIsDirtyTriggers: boolean, isDirtyFromMachine: boolean, alertsLength: number) => boolean;
+export {};

package/features/form-runtime/utils/formDataBuilder.d.ts

@@ -0,0 +1,7 @@
+import { FormStepConfig } from '../../../../../core/src/index.ts';
+/**
+ * Form data builder following functional programming principles
+ * Single Responsibility: Only builds form default values
+ * Pure function - no side effects, same input = same output
+ */
+export declare const buildDefaultValues: (step: FormStepConfig) => Record<string, unknown>;

package/features/form-runtime/utils/formDirtyStateSync.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Utility functions for synchronizing TanStack Form dirty state with API data population
+ *
+ * The problem: When API populates form fields after initial load, TanStack Form marks
+ * them as dirty because they changed from their initial empty state. This breaks
+ * our trigger system that needs to distinguish between API-populated values and
+ * user-initiated changes.
+ *
+ * The solution: After API population, reset the form's dirty state by updating
+ * TanStack Form's internal tracking so it considers the API-populated values
+ * as the new "clean" state.
+ */
+export interface FormDirtySyncOptions {
+    /**
+     * Component IDs that were updated by API calls
+     * If not provided, will attempt to reset all fields
+     */
+    updatedFields?: string[];
+    /**
+     * Whether to log debug information about the reset process
+     */
+    debug?: boolean;
+}
+/**
+ * Reset TanStack Form's dirty state after API data population
+ *
+ * This function resets field states so that API-populated values are treated
+ * as the new "clean" baseline state, preventing them from being marked as dirty.
+ *
+ * The approach:
+ * Based on TanStack Form v1.19+ API documentation:
+ * 1. Get current field values before reset
+ * 2. Use resetField() to reset field meta to default state
+ * 3. Set field values with proper UpdateMetaOptions to avoid marking as touched/dirty
+ * 4. TanStack Form's resetField() resets both value and meta to defaults
+ *
+ * @param form - TanStack Form instance
+ * @param options - Configuration options
+ */
+export declare function resetFormDirtyStateAfterApiPopulation(form: unknown, options?: FormDirtySyncOptions): void;
+/**
+ * Optimized approach for API data population
+ * This function updates form state and original values without triggering useEffect loops
+ *
+ * Usage after API data is received:
+ * 1. Call this function with form instance and field data
+ * 2. No more useEffect cascades or performance issues
+ * 3. Proper dirty state management for isDirty triggers
+ *
+ * Based on TanStack Form best practices:
+ * - Use dontUpdateMeta option to prevent marking fields as dirty during API population
+ * - Reset fields first, then set values to establish clean baseline
+ *
+ * @param form - TanStack Form instance
+ * @param fieldsData - Object mapping field IDs to their API-populated values
+ * @param debug - Whether to log debug information
+ */
+export declare function handleApiDataPopulation(form: unknown, fieldsData: Record<string, unknown>, debug?: boolean): void;
+/**
+ * Enhanced API population helper that integrates with XState machine
+ *
+ * This function combines TanStack Form sync with XState original value tracking
+ * for clean isDirty detection in the trigger-action system.
+ *
+ * @param form - TanStack Form instance
+ * @param formHelpers - Helpers from useFormMachine (destructured helpers object)
+ * @param fieldsData - Object mapping field IDs to their API-populated values
+ * @param debug - Whether to log debug information
+ */
+export declare function handleApiDataPopulationWithOriginalTracking(form: unknown, formHelpers: {
+    markComponentAsPopulated: (componentId: string, value: unknown) => void;
+}, fieldsData: Record<string, unknown>, debug?: boolean): void;
+/**
+ * Check if specific fields are dirty and log detailed information
+ * Useful for debugging dirty state issues
+ */
+export declare function debugFormDirtyState(form: unknown, fieldNames?: string[]): void;

package/features/form-runtime/utils/formSaver.d.ts

@@ -0,0 +1,22 @@
+import { FormWizardConfig } from '../../../../../core/src/index.ts';
+export interface SaveResult {
+    success: boolean;
+    error?: {
+        message: string;
+        code?: string;
+    };
+    metadata?: {
+        filePath?: string;
+        timestamp?: number;
+    };
+}
+/**
+ * Save form configuration using the pluggable save provider system
+ * This is a self-contained function that doesn't rely on external utilities
+ */
+export declare function saveFormConfig(projectId: string, wizardId: string, config: FormWizardConfig): Promise<SaveResult>;
+/**
+ * Load form configuration
+ * Companion function to saveFormConfig for loading saved forms
+ */
+export declare function loadFormConfig(projectId: string, wizardId: string): Promise<FormWizardConfig | null>;

package/features/form-runtime/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './errorUtils';
+export * from './validation';
+export * from './validationUX';
+export * from './visibilityUtils';

package/features/form-runtime/utils/logger.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Logger utility for form field debugging
+ * Can be enabled/disabled via environment variables or runtime configuration
+ */
+interface LoggerConfig {
+    enabled: boolean;
+    level: "debug" | "info" | "warn" | "error";
+}
+declare class FormFieldLogger {
+    private config;
+    constructor();
+    private getInitialEnabledState;
+    /**
+     * Enable or disable logging
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if logging is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Set logging level
+     */
+    setLevel(level: LoggerConfig["level"]): void;
+    /**
+     * Debug level logging
+     */
+    debug(message: string, data?: any): void;
+    /**
+     * Info level logging
+     */
+    info(message: string, data?: any): void;
+    /**
+     * Warning level logging
+     */
+    warn(message: string, data?: any): void;
+    /**
+     * Error level logging (always shown regardless of enabled state)
+     */
+    error(message: string, data?: any): void;
+    /**
+     * Critical error logging (always shown regardless of enabled state)
+     */
+    critical(message: string, data?: any): void;
+    /**
+     * Validation specific logging
+     */
+    validation(message: string, data?: any): void;
+    /**
+     * State management specific logging
+     */
+    state(message: string, data?: any): void;
+    /**
+     * Component lifecycle logging
+     */
+    lifecycle(message: string, data?: any): void;
+    /**
+     * Change event logging
+     */
+    change(message: string, data?: any): void;
+    /**
+     * Test/experimental logging
+     */
+    test(message: string, data?: any): void;
+}
+export declare const logger: FormFieldLogger;
+export declare const enableFormFieldLogging: () => void;
+export declare const disableFormFieldLogging: () => void;
+export declare const isFormFieldLoggingEnabled: () => boolean;
+export {};

package/features/form-runtime/utils/validation.d.ts

@@ -0,0 +1,3 @@
+import { ComponentConfig, FlowData, FormFieldValue, ValidationRule } from '../../../../../core/src/index.ts';
+export declare const validateComponentValue: (component: ComponentConfig, value: FormFieldValue, formData: FlowData) => string[];
+export declare const validateRule: (rule: ValidationRule, value: FormFieldValue, formData: FlowData) => boolean;

package/features/form-runtime/utils/validationUX.d.ts

@@ -0,0 +1,70 @@
+export declare const markFieldAsUserInteracted: (componentId: string) => void;
+export declare const hasUserInteracted: (componentId: string) => boolean;
+export declare const clearUserInteractionTracking: () => void;
+export declare const shouldShowValidationError: (fieldMeta: any, // Using any for compatibility with TanStack Form's complex FieldMeta type
+isSubmitAttempted?: boolean, componentId?: string) => boolean;
+export declare const updateValidationCache: (componentId: string, isValid: boolean) => void;
+/**
+ * Gets the most appropriate error message to display based on validation state
+ * and UX best practices
+ */
+export declare const getDisplayErrorMessage: (fieldMeta: any, // Using any for compatibility with TanStack Form's complex FieldMeta type
+isSubmitAttempted?: boolean) => string;
+/**
+ * Validation timing strategies for different field types
+ */
+export declare const VALIDATION_TIMING: {
+    readonly textInput: {
+        readonly validateOn: "blur";
+        readonly showErrorsAfter: "touch";
+    };
+    readonly email: {
+        readonly validateOn: "blur";
+        readonly showErrorsAfter: "touch";
+    };
+    readonly number: {
+        readonly validateOn: "blur";
+        readonly showErrorsAfter: "touch";
+    };
+    readonly radioGroup: {
+        readonly validateOn: "change";
+        readonly showErrorsAfter: "touch";
+    };
+    readonly select: {
+        readonly validateOn: "change";
+        readonly showErrorsAfter: "touch";
+    };
+    readonly checkbox: {
+        readonly validateOn: "change";
+        readonly showErrorsAfter: "touch";
+    };
+    readonly multiselect: {
+        readonly validateOn: "change";
+        readonly showErrorsAfter: "touch";
+    };
+};
+/**
+ * Gets the validation timing strategy for a component type
+ */
+export declare const getValidationTiming: (componentType: string) => {
+    readonly validateOn: "blur";
+    readonly showErrorsAfter: "touch";
+} | {
+    readonly validateOn: "blur";
+    readonly showErrorsAfter: "touch";
+} | {
+    readonly validateOn: "blur";
+    readonly showErrorsAfter: "touch";
+} | {
+    readonly validateOn: "change";
+    readonly showErrorsAfter: "touch";
+} | {
+    readonly validateOn: "change";
+    readonly showErrorsAfter: "touch";
+} | {
+    readonly validateOn: "change";
+    readonly showErrorsAfter: "touch";
+} | {
+    readonly validateOn: "change";
+    readonly showErrorsAfter: "touch";
+};

package/features/form-runtime/utils/visibilityUtils.d.ts

@@ -0,0 +1,13 @@
+import { FormData, VisibilityConditionConfig } from '../../../../../core/src/index.ts';
+/**
+ * Evaluates whether a component should be visible based on its visibility conditions
+ * @param visibilityConfig The visibility condition configuration
+ * @param formData Current form data values
+ * @returns true if component should be visible, false if hidden
+ */
+export declare function evaluateVisibility(visibilityConfig: VisibilityConditionConfig | undefined, formData: FormData): boolean;
+/**
+ * Gets all field IDs that are referenced in visibility conditions
+ * This is useful for optimizing re-renders - only re-evaluate when these fields change
+ */
+export declare function getVisibilityDependencies(visibilityConfig: VisibilityConditionConfig | undefined): string[];

package/features/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Form Wizard Component Features
+ *
+ * Feature-based exports for the form wizard component
+ */
+export * from './api-integration';
+export * from './dialog-system';
+export * from './form-runtime';
+export * from './state-management';
+export * from './trigger-action-system';
+export * from './validation-system';

package/features/state-management/components/ValidationBuilder/ValidationBuilder.d.ts

@@ -0,0 +1,9 @@
+import { ComponentValidation } from '../../machines/validation/validationTypes';
+interface ValidationBuilderProps {
+    componentType: string;
+    componentLabel: string;
+    validation: ComponentValidation;
+    onChange: (validation: ComponentValidation) => void;
+}
+export declare const ValidationBuilder: React.FC<ValidationBuilderProps>;
+export {};

package/features/state-management/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * State Management Feature
+ *
+ * XState machines and state management for forms
+ */
+export * from './machines';
+export * from './machines/componentTriggerEngine';
+export { default as useFormMachine } from './machines/useFormMachine';

package/features/state-management/machines/__tests__/testUtils.d.ts

@@ -0,0 +1,78 @@
+import { ComponentAction, ComponentConfig, ComponentTrigger, FormWizardConfig } from '../../../../../../core/src/index.ts';
+import { FormMachineContext, FormMachineEvents } from '../types';
+/**
+ * Test utilities for form machine testing
+ */
+export declare function createMockConfig(overrides?: Partial<FormWizardConfig>): FormWizardConfig;
+export declare function createMockComponentWithTriggers(componentId: string, triggers: ComponentTrigger[]): ComponentConfig;
+export declare function createMockTrigger(type: ComponentTrigger["type"], actions: ComponentAction[], overrides?: Partial<ComponentTrigger>): ComponentTrigger;
+export declare function createMockAction(type: ComponentAction["type"], config?: any, overrides?: Partial<ComponentAction>): ComponentAction;
+export declare function createMockContext(overrides?: Partial<FormMachineContext>): FormMachineContext;
+export declare const mockEvents: {
+    setData: (key: string, value: any) => FormMachineEvents;
+    next: () => FormMachineEvents;
+    previous: () => FormMachineEvents;
+    goToStep: (stepId: string) => FormMachineEvents;
+    evaluateComponentTriggers: (componentId: string, value?: any) => FormMachineEvents;
+    triggerComponentAction: (componentId: string, triggerId: string, actionId: string) => FormMachineEvents;
+    showComponentAlert: (componentId: string, message: string) => FormMachineEvents;
+    setComponentOriginalValue: (componentId: string, value: any, source?: "initialized" | "api_populated" | "user_reset") => FormMachineEvents;
+    startSave: (sectionId: string) => FormMachineEvents;
+    submit: () => FormMachineEvents;
+    reset: () => FormMachineEvents;
+};
+export declare function createMachineTestSetup(initialContext?: Partial<FormMachineContext>): {
+    context: FormMachineContext;
+    input: {
+        input: FormMachineContext;
+    };
+    mockEvents: {
+        setData: (key: string, value: any) => FormMachineEvents;
+        next: () => FormMachineEvents;
+        previous: () => FormMachineEvents;
+        goToStep: (stepId: string) => FormMachineEvents;
+        evaluateComponentTriggers: (componentId: string, value?: any) => FormMachineEvents;
+        triggerComponentAction: (componentId: string, triggerId: string, actionId: string) => FormMachineEvents;
+        showComponentAlert: (componentId: string, message: string) => FormMachineEvents;
+        setComponentOriginalValue: (componentId: string, value: any, source?: "initialized" | "api_populated" | "user_reset") => FormMachineEvents;
+        startSave: (sectionId: string) => FormMachineEvents;
+        submit: () => FormMachineEvents;
+        reset: () => FormMachineEvents;
+    };
+};
+export declare const testScenarios: {
+    dirtyFieldWithTrigger: {
+        componentId: string;
+        originalValue: string;
+        newValue: string;
+        triggerId: string;
+        actionId: string;
+    };
+    multiStepNavigation: {
+        totalSteps: number;
+        currentStep: number;
+        targetStep: number;
+    };
+    saveFlow: {
+        sectionId: string;
+        componentIds: string[];
+    };
+};
+export declare function expectStateTransition(fromState: string, toState: string, event: FormMachineEvents): {
+    from: string;
+    to: string;
+    event: FormMachineEvents;
+};
+export declare function expectContextUpdate(path: string, expectedValue: any): {
+    path: string;
+    expectedValue: any;
+};
+export declare const mockServices: {
+    apiCall: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    emailVerification: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    saveSection: import('vitest').Mock<import('@vitest/spy').Procedure>;
+};
+export declare const commonConfigs: {
+    singleStep: FormWizardConfig;
+    multipleTriggersConfig: FormWizardConfig;
+};

package/features/state-management/machines/__tests__/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;