@digiform/wizard 0.1.7 → 0.2.2

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

@@ -0,0 +1,5 @@
+export * from './validateField';
+export * from './validateForm';
+export * from './validateSection';
+export * from './validateStep';
+export * from './validationTypes';

package/features/state-management/machines/validation/validateField.d.ts

@@ -0,0 +1,2 @@
+import { FormMachineContext } from '../types';
+export declare const validateField: (context: FormMachineContext, fieldName: string) => string | null;

package/features/state-management/machines/validation/validateForm.d.ts

@@ -0,0 +1,2 @@
+import { FormMachineContext } from '../types';
+export declare const validateForm: (context: FormMachineContext) => Record<string, string[]>;

package/features/state-management/machines/validation/validateSection.d.ts

@@ -0,0 +1,2 @@
+import { FormMachineContext } from '../types';
+export declare const validateSection: (context: FormMachineContext, sectionId: string) => Record<string, string[]>;

package/features/state-management/machines/validation/validateStep.d.ts

@@ -0,0 +1,2 @@
+import { FormMachineContext } from '../types';
+export declare const validateStep: (context: FormMachineContext, stepId: string) => Record<string, string[]>;

package/features/state-management/machines/validation/validationTypes.d.ts

@@ -0,0 +1 @@
+export { type ComponentConfig, type ComponentValidation, DEFAULT_VALIDATION_MESSAGES, getValidationMessage, type SecureCustomValidator, type ValidationRule, } from '../../../../../../core/src/index.ts';

package/features/trigger-action-system/components/ActionLoadingIndicator/ActionLoadingIndicator.d.ts

@@ -0,0 +1,8 @@
+import { ActionExecution } from '../../../../../../core/src/index.ts';
+interface ActionLoadingIndicatorProps {
+    activeActions: Record<string, ActionExecution>;
+    className?: string;
+}
+declare const ActionLoadingIndicator: import('react').NamedExoticComponent<ActionLoadingIndicatorProps>;
+export { ActionLoadingIndicator };
+export default ActionLoadingIndicator;

package/features/trigger-action-system/components/ActionManager.d.ts

@@ -0,0 +1,6 @@
+interface ActionManagerProps {
+    className?: string;
+}
+declare const ActionManager: import('react').NamedExoticComponent<ActionManagerProps>;
+export { ActionManager };
+export default ActionManager;

package/features/trigger-action-system/components/ComponentAlert/ComponentAlert.d.ts

@@ -0,0 +1,10 @@
+import { ComponentAlert as ComponentAlertType } from '../../../state-management/machines/types';
+interface ComponentAlertProps {
+    alert: ComponentAlertType;
+}
+export declare const ComponentAlert: React.FC<ComponentAlertProps>;
+interface ComponentAlertsProps {
+    alerts: ComponentAlertType[];
+}
+export declare const ComponentAlerts: React.FC<ComponentAlertsProps>;
+export default ComponentAlert;

package/features/trigger-action-system/components/FieldWarning/FieldWarning.d.ts

@@ -0,0 +1,20 @@
+import { FieldWarning as FieldWarningType } from '../../../../../../core/src/index.ts';
+import { default as React } from 'react';
+interface FieldWarningProps {
+    warning: FieldWarningType;
+    onDismiss?: (warningId: string) => void;
+    className?: string;
+}
+export declare const FieldWarning: React.FC<FieldWarningProps>;
+interface FieldWarningListProps {
+    fieldId: string;
+    warnings: FieldWarningType[];
+    onDismiss?: (warningId: string) => void;
+    className?: string;
+}
+/**
+ * Component to display multiple warnings for a field
+ * Handles spacing and layout of multiple warnings
+ */
+export declare const FieldWarningList: React.FC<FieldWarningListProps>;
+export default FieldWarning;

package/features/trigger-action-system/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Trigger-Action System Feature
+ *
+ * Components and utilities for handling component triggers and actions
+ */
+export { default as ActionLoadingIndicator } from './components/ActionLoadingIndicator/ActionLoadingIndicator';
+export { default as ActionManager } from './components/ActionManager';
+export { default as ComponentAlert } from './components/ComponentAlert/ComponentAlert';
+export { createTriggerContext, GenericTriggerEngine, } from './utils/GenericTriggerEngine';
+export type { EnhancedComponentConfig, EnhancedFormConfig, EnhancedSectionConfig, EnhancedStepConfig, ExtendedAction, ExtendedActionConfig, ExtendedActionType, ExtendedComponentActionConfig, ExtendedTrigger, ExtendedTriggerActionContainer, ExtendedTriggerCondition, ExtendedTriggerContext, ExtendedTriggerType, } from './utils/triggerActionSystem';

package/features/trigger-action-system/utils/GenericTriggerEngine.d.ts

@@ -0,0 +1,118 @@
+import { DataService, ExtendedTrigger, ExtendedTriggerContext, ExtendedTriggerType, NavigationService, TriggerEvaluationContext, UIService, ValidationService } from './triggerActionSystem';
+export declare class GenericTriggerEngine {
+    private services;
+    private triggers;
+    private debounceTimers;
+    private throttleTimers;
+    constructor(services: {
+        navigation: NavigationService;
+        ui: UIService;
+        data: DataService;
+        validation: ValidationService;
+    });
+    /**
+     * Register triggers for a specific context and target
+     */
+    registerTriggers(targetId: string, triggers: ExtendedTrigger[]): void;
+    /**
+     * Unregister triggers for a target
+     */
+    unregisterTriggers(targetId: string): void;
+    /**
+     * Evaluate triggers for a given context
+     */
+    evaluateTriggers(context: TriggerEvaluationContext): Promise<void>;
+    /**
+     * Execute a single trigger
+     */
+    private executeTrigger;
+    /**
+     * Execute actions for a trigger
+     */
+    private executeActions;
+    /**
+     * Execute a single action
+     */
+    private executeAction;
+    /**
+     * Dispatch action to appropriate handler based on type
+     */
+    private dispatchAction;
+    /**
+     * Evaluate trigger conditions
+     */
+    private evaluateConditions;
+    /**
+     * Evaluate a single condition
+     */
+    private evaluateCondition;
+    /**
+     * Handle debouncing for triggers
+     */
+    private handleDebounce;
+    /**
+     * Check if trigger is currently throttled
+     */
+    private isThrottled;
+    /**
+     * Set throttle timer for trigger
+     */
+    private setThrottle;
+    /**
+     * Clear all timers for a target
+     */
+    private clearTimers;
+    /**
+     * Handle component-specific actions
+     */
+    private handleComponentAction;
+    /**
+     * Handle original value updates
+     */
+    private handleUpdateOriginalValue;
+    /**
+     * Handle custom actions
+     */
+    private handleCustomAction;
+    /**
+     * Evaluate custom conditions
+     */
+    private evaluateCustomCondition;
+    /**
+     * Emit events for external handling
+     */
+    private emitEvent;
+    /**
+     * Type guards for action config validation
+     */
+    private isTypedActionConfig;
+    private isUIShowAlertConfig;
+    private isUIShowDialogConfig;
+    private isUIShowNotificationConfig;
+    private isNavigationGoToStepConfig;
+    private isNavigationGoNextConfig;
+    private isNavigationGoPreviousConfig;
+    private isNavigationGoToSectionConfig;
+    private isComponentEnableConfig;
+    private isComponentDisableConfig;
+    private isComponentShowHideConfig;
+    private isComponentSetValueConfig;
+    private isComponentUpdateOriginalValueConfig;
+    private isDataApiCallConfig;
+    private isDataSetValueConfig;
+    private isDataValidationConfig;
+    private isCustomActionConfig;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+}
+/**
+ * Utility function to create trigger evaluation context
+ */
+export declare function createTriggerContext(triggerType: ExtendedTriggerType, context: ExtendedTriggerContext, targetId: string, options?: {
+    currentValue?: unknown;
+    previousValue?: unknown;
+    formData?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}): TriggerEvaluationContext;

package/features/trigger-action-system/utils/triggerActionSystem.d.ts

@@ -0,0 +1,193 @@
+import { ComponentActionConfig, GenericAction, GenericActionType, GenericTrigger, GenericTriggerCondition, GenericTriggerType, TriggerActionContainer, TriggerContext } from '../../../../../core/src/index.ts';
+export type { GenericAction, GenericTrigger, GenericTriggerCondition, GenericTriggerType, TriggerContext, };
+export type ExtendedTriggerContext = TriggerContext | "component" | "section" | "step" | "form";
+export type ExtendedTriggerType = GenericTriggerType | "component:isDirty" | "component:onValueChange" | "component:onFocus" | "component:onBlur" | "component:onMount" | "component:onUnmount" | "section:onSave" | "section:onCancel" | "section:onEdit" | "section:onMount" | "section:onValidation" | "step:onLoad" | "step:onFinish" | "step:onNext" | "step:onPrevious" | "step:onMount" | "step:onUnmount" | "step:onValidation" | "form:onSubmit" | "form:onReset" | "form:onMount" | "form:onUnmount" | "form:onValidation";
+export type ExtendedActionType = GenericActionType | "ui:showAlert" | "ui:showDialog" | "ui:hideDialog" | "ui:showNotification" | "navigation:goToStep" | "navigation:goNext" | "navigation:goPrevious" | "navigation:goToSection" | "component:enable" | "component:disable" | "component:show" | "component:hide" | "component:setValue" | "component:clearValue" | "component:updateOriginalValue" | "data:apiCall" | "data:setValue" | "data:clearValue" | "data:validateField" | "data:validateSection" | "data:validateStep" | "custom:execute";
+export interface ExtendedTriggerCondition extends Omit<GenericTriggerCondition, "operator"> {
+    id?: string;
+    operator: "equals" | "notEquals" | "contains" | "empty" | "notEmpty" | "isSet" | "isNotSet" | "notContains" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "in" | "notIn" | "matches" | "custom";
+    values?: unknown[];
+    customEvaluator?: string;
+    logicalOperator?: "AND" | "OR";
+}
+export interface ExtendedTrigger extends Omit<GenericTrigger, "type" | "conditions"> {
+    type: ExtendedTriggerType;
+    context?: ExtendedTriggerContext;
+    conditions?: ExtendedTriggerCondition[];
+    actions?: ExtendedAction[];
+    enabled?: boolean;
+    order?: number;
+    debounceMs?: number;
+    throttleMs?: number;
+}
+export interface ExtendedAction extends Omit<GenericAction, "type" | "config"> {
+    type: ExtendedActionType;
+    config: ExtendedActionConfig;
+    enabled?: boolean;
+    delay?: number;
+    condition?: ExtendedTriggerCondition;
+}
+export type ExtendedActionConfig = GenericAction["config"] | UIActionConfig | NavigationActionConfig | ExtendedComponentActionConfig | DataActionConfig | CustomActionConfig;
+export interface UIShowAlertConfig {
+    type: "ui:showAlert";
+    message: string;
+    alertType: "info" | "warning" | "error" | "success";
+    position: "inline" | "tooltip" | "sidebar" | "toast";
+    dismissible?: boolean;
+    autoHide?: boolean;
+    autoHideDelay?: number;
+    targetId?: string;
+}
+export interface UIShowDialogConfig {
+    type: "ui:showDialog";
+    dialogType: "confirmation" | "email-verification" | "custom";
+    template?: string;
+    title?: string;
+    content?: string;
+    buttons?: DialogButtonConfig[];
+    templateConfig?: Record<string, unknown>;
+}
+export interface UIShowNotificationConfig {
+    type: "ui:showNotification";
+    message: string;
+    notificationType: "info" | "warning" | "error" | "success";
+    duration?: number;
+    position?: "top" | "bottom" | "top-right" | "bottom-right";
+}
+export interface NavigationGoToStepConfig {
+    type: "navigation:goToStep";
+    stepId: string;
+    behavior?: "replace" | "push";
+}
+export interface NavigationGoNextConfig {
+    type: "navigation:goNext";
+    skipValidation?: boolean;
+}
+export interface NavigationGoPreviousConfig {
+    type: "navigation:goPrevious";
+    skipValidation?: boolean;
+}
+export interface NavigationGoToSectionConfig {
+    type: "navigation:goToSection";
+    sectionId: string;
+    stepId?: string;
+}
+export interface ComponentEnableConfig {
+    type: "component:enable";
+    componentIds: string[];
+}
+export interface ComponentDisableConfig {
+    type: "component:disable";
+    componentIds: string[];
+}
+export interface ComponentShowHideConfig {
+    type: "component:show" | "component:hide";
+    componentIds: string[];
+    animation?: "fade" | "slide" | "none";
+}
+export interface ComponentSetValueConfig {
+    type: "component:setValue" | "component:clearValue";
+    componentId: string;
+    value?: unknown;
+}
+export interface ComponentUpdateOriginalValueConfig {
+    type: "component:updateOriginalValue";
+    componentId: string;
+}
+export interface DataApiCallConfig {
+    type: "data:apiCall";
+    url: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+    timeout?: number;
+    retryCount?: number;
+    fieldMappings?: Record<string, string>;
+    onSuccess?: ExtendedAction[];
+    onError?: ExtendedAction[];
+}
+export interface DataSetValueConfig {
+    type: "data:setValue" | "data:clearValue";
+    fieldPath: string;
+    value?: unknown;
+}
+export interface DataValidationConfig {
+    type: "data:validateField" | "data:validateSection" | "data:validateStep";
+    targetId: string;
+    showErrors?: boolean;
+}
+export interface CustomActionConfig {
+    type: "custom:execute";
+    handler: string;
+    parameters?: Record<string, unknown>;
+}
+export type UIActionConfig = UIShowAlertConfig | UIShowDialogConfig | UIShowNotificationConfig;
+export type NavigationActionConfig = NavigationGoToStepConfig | NavigationGoNextConfig | NavigationGoPreviousConfig | NavigationGoToSectionConfig;
+export type ExtendedComponentActionConfig = ComponentActionConfig | ComponentEnableConfig | ComponentDisableConfig | ComponentShowHideConfig | ComponentSetValueConfig | ComponentUpdateOriginalValueConfig;
+export type DataActionConfig = DataApiCallConfig | DataSetValueConfig | DataValidationConfig;
+export interface DialogButtonConfig {
+    id: string;
+    label: string;
+    variant?: "default" | "secondary" | "destructive" | "outline" | "ghost";
+    action: ExtendedAction;
+}
+export interface ExtendedTriggerActionContainer extends Omit<TriggerActionContainer, "triggers" | "actions"> {
+    triggers: ExtendedTrigger[];
+    actions?: ExtendedAction[];
+}
+export interface EnhancedComponentConfig {
+    triggerActions?: ExtendedTriggerActionContainer;
+}
+export interface EnhancedSectionConfig {
+    triggerActions?: ExtendedTriggerActionContainer;
+}
+export interface EnhancedStepConfig {
+    triggerActions?: ExtendedTriggerActionContainer;
+}
+export interface EnhancedFormConfig {
+    triggerActions?: ExtendedTriggerActionContainer;
+}
+export interface TriggerEvaluationContext {
+    triggerType: ExtendedTriggerType;
+    context: ExtendedTriggerContext;
+    targetId: string;
+    currentValue?: unknown;
+    previousValue?: unknown;
+    formData: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    timestamp: number;
+}
+export interface ActionExecutionContext {
+    action: ExtendedAction;
+    triggerContext: TriggerEvaluationContext;
+    formData: Record<string, unknown>;
+    services: {
+        navigation: NavigationService;
+        ui: UIService;
+        data: DataService;
+        validation: ValidationService;
+    };
+}
+export interface NavigationService {
+    goToStep(stepId: string, behavior?: "replace" | "push"): void;
+    goNext(skipValidation?: boolean): void;
+    goPrevious(skipValidation?: boolean): void;
+    goToSection(sectionId: string, stepId?: string): void;
+}
+export interface UIService {
+    showAlert(config: UIShowAlertConfig): void;
+    showDialog(config: UIShowDialogConfig): void;
+    showNotification(config: UIShowNotificationConfig): void;
+    hideDialog(): void;
+}
+export interface DataService {
+    apiCall(config: DataApiCallConfig): Promise<unknown>;
+    setValue(fieldPath: string, value: unknown): void;
+    getValue(fieldPath: string): unknown;
+    clearValue(fieldPath: string): void;
+}
+export interface ValidationService {
+    validateField(fieldId: string): boolean;
+    validateSection(sectionId: string): boolean;
+    validateStep(stepId: string): boolean;
+}

package/features/validation-system/components/ValidationDebugger.d.ts

@@ -0,0 +1,2 @@
+declare const ValidationDebugger: React.FC;
+export default ValidationDebugger;

package/features/validation-system/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validation System Feature
+ *
+ * Components and utilities for form validation
+ */
+export { default as ValidationDebugger } from './components/ValidationDebugger';
+export * from './validation';

package/features/validation-system/validation/ActionValidation.d.ts

@@ -0,0 +1,54 @@
+import { ApiCallConfig, DialogConfig, FormAction, FormStepConfig, NavigationConfig, TemplateDialogConfig } from '../../../../../core/src/index.ts';
+export declare class ActionValidationError extends Error {
+    actionId: string;
+    actionType: string;
+    details?: any | undefined;
+    constructor(actionId: string, actionType: string, message: string, details?: any | undefined);
+}
+export declare class ActionValidator {
+    /**
+     * Validates a single action configuration
+     */
+    static validateAction(action: FormAction): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Validates API call configuration
+     */
+    static validateApiCallConfig(config: ApiCallConfig): string[];
+    /**
+     * Validates dialog configuration - supports both direct and template-based configs
+     */
+    static validateDialogConfig(config: DialogConfig | TemplateDialogConfig): string[];
+    /**
+     * Validates template-based dialog configuration
+     */
+    static validateTemplateDialogConfig(config: TemplateDialogConfig): string[];
+    /**
+     * Validates resolved dialog configuration (after template resolution)
+     */
+    static validateResolvedDialogConfig(config: DialogConfig): string[];
+    /**
+     * Validates dialog button action
+     */
+    static validateDialogButtonAction(action: any, buttonIndex: number): string[];
+    /**
+     * Validates navigation configuration
+     */
+    static validateNavigationConfig(config: NavigationConfig): string[];
+    /**
+     * Validates all actions in a step
+     */
+    static validateStepActions(step: FormStepConfig): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Validates navigation targets exist
+     */
+    static validateNavigationTargets(step: FormStepConfig, allSteps: FormStepConfig[]): {
+        isValid: boolean;
+        errors: string[];
+    };
+}

package/features/validation-system/validation/SchemaBuilder.d.ts

@@ -0,0 +1,36 @@
+import { ComponentConfig, FormStepConfig } from '../../../../../core/src/index.ts';
+import { z } from 'zod';
+import { SecureValidatorConfig } from './secureValidatorEngine';
+export type MessageStyle = "withLabel" | "simple";
+/**
+ * SchemaBuilder - Creates and manages Zod schemas for validation
+ */
+export declare class SchemaBuilder {
+    private messageStyle;
+    private secureValidatorConfig?;
+    constructor(messageStyle?: MessageStyle, secureValidatorConfig?: Partial<SecureValidatorConfig>);
+    /**
+     * Creates a Zod schema for a component
+     */
+    createComponentSchema(component: ComponentConfig): z.ZodTypeAny;
+    /**
+     * Creates a Zod schema for a step
+     */
+    createStepSchema(step: FormStepConfig): z.ZodTypeAny;
+    /**
+     * Updates the message style
+     */
+    updateMessageStyle(messageStyle: MessageStyle): void;
+    /**
+     * Updates the secure validator config
+     */
+    updateSecureValidatorConfig(config: Partial<SecureValidatorConfig>): void;
+    /**
+     * Gets the current message style
+     */
+    getMessageStyle(): MessageStyle;
+    /**
+     * Checks if a component is required based on its validation configuration
+     */
+    private isComponentRequired;
+}

package/features/validation-system/validation/ValidationCache.d.ts

@@ -0,0 +1,36 @@
+import { ComponentConfig, FormStepConfig } from '../../../../../core/src/index.ts';
+import { z } from 'zod';
+import { SchemaBuilder } from './SchemaBuilder';
+/**
+ * ValidationCache - Manages schema caching and cache invalidation
+ */
+export declare class ValidationCache {
+    private schemaBuilder;
+    private componentSchemaCache;
+    private stepSchemaCache;
+    constructor(schemaBuilder: SchemaBuilder);
+    /**
+     * Gets or creates a component schema with caching
+     */
+    getComponentSchema(component: ComponentConfig): z.ZodTypeAny;
+    /**
+     * Gets or creates a step schema with caching
+     */
+    getStepSchema(step: FormStepConfig): z.ZodTypeAny;
+    /**
+     * Clears all cached schemas
+     */
+    clearCache(): void;
+    /**
+     * Invalidates cache when message style changes
+     */
+    invalidateOnMessageStyleChange(): void;
+    /**
+     * Clears cache for a specific component
+     */
+    clearComponentCache(componentId: string): void;
+    /**
+     * Clears cache for a specific step
+     */
+    clearStepCache(stepId: string): void;
+}

package/features/validation-system/validation/ValidationEngine.d.ts

@@ -0,0 +1,86 @@
+import { ComponentConfig, FormData, FormStepConfig, FormWizardConfig } from '../../../../../core/src/index.ts';
+import { z } from 'zod';
+import { SecureValidatorConfig } from './secureValidatorEngine';
+import { FieldValidationResult, ValidationResult } from './ValidationExecutor';
+export type { FieldValidationResult, ValidationResult, } from './ValidationExecutor';
+/**
+ * Validation options
+ */
+export interface ValidationOptions {
+    messageStyle?: "withLabel" | "simple";
+    debounceMs?: number;
+    secureValidatorConfig?: Partial<SecureValidatorConfig>;
+}
+/**
+ * Gets default values for a form step based on component types
+ */
+export declare const getStepDefaultValues: (step: FormStepConfig) => Record<string, unknown>;
+/**
+ * Gets a human-readable representation of validation schema for debugging
+ */
+export declare const getReadableValidationSchema: (step: FormStepConfig) => string;
+/**
+ * Unified ValidationEngine class that consolidates all validation logic
+ * Features:
+ * - Debounced validation for performance
+ * - Schema caching with memoization
+ * - Single API for all validation needs
+ * - Support for field, step, and form-level validation
+ *
+ * This class acts as a facade that orchestrates three main components:
+ * - SchemaBuilder: Creates and builds Zod schemas
+ * - ValidationExecutor: Executes validation logic and processes results
+ * - ValidationCache: Manages schema caching and cache invalidation
+ */
+export declare class ValidationEngine {
+    private debounceTimers;
+    private debounceMs;
+    private schemaBuilder;
+    private validationExecutor;
+    private validationCache;
+    constructor(options?: ValidationOptions);
+    /**
+     * Validates a single field with debouncing
+     */
+    validateFieldDebounced(component: ComponentConfig, value: unknown): Promise<FieldValidationResult>;
+    /**
+     * Validates a single field immediately (synchronous)
+     */
+    validateField(component: ComponentConfig, value: unknown): FieldValidationResult;
+    /**
+     * Validates all fields in a step
+     */
+    validateStep(step: FormStepConfig, data: FormData): Promise<ValidationResult>;
+    /**
+     * Validates an entire form
+     */
+    validateForm(config: FormWizardConfig, data: FormData): Promise<ValidationResult>;
+    /**
+     * Creates and caches a Zod schema for a component
+     */
+    getComponentSchema(component: ComponentConfig): unknown;
+    /**
+     * Creates a Zod schema for an entire step
+     */
+    getStepSchema(step: FormStepConfig): z.ZodTypeAny;
+    /**
+     * Clears the schema cache (useful when component configurations change)
+     */
+    clearCache(): void;
+    /**
+     * Clears debounce timers
+     */
+    cancelPendingValidations(): void;
+    /**
+     * Updates validation options
+     */
+    updateOptions(options: ValidationOptions): void;
+}
+/**
+ * Default global validation engine instance
+ */
+export declare const defaultValidationEngine: ValidationEngine;
+/**
+ * Hook to get validation engine with form-specific options
+ */
+export declare function createValidationEngine(options?: ValidationOptions): ValidationEngine;

package/features/validation-system/validation/ValidationExecutor.d.ts

@@ -0,0 +1,36 @@
+import { FormWizardConfig } from '../../../../../core/src/index.ts';
+import { z } from 'zod';
+import { SchemaBuilder } from './SchemaBuilder';
+export interface FieldValidationResult {
+    isValid: boolean;
+    errors: string[];
+    value: unknown;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    fieldErrors: Record<string, string[]>;
+    generalErrors: string[];
+}
+/**
+ * ValidationExecutor - Executes validation logic and processes results
+ */
+export declare class ValidationExecutor {
+    private schemaBuilder;
+    constructor(schemaBuilder: SchemaBuilder);
+    /**
+     * Validates a single field
+     */
+    validateField(value: unknown, schema: z.ZodTypeAny): Promise<FieldValidationResult>;
+    /**
+     * Validates a single field synchronously
+     */
+    validateFieldSync(value: unknown, schema: z.ZodTypeAny): FieldValidationResult;
+    /**
+     * Validates a step
+     */
+    validateStep(data: Record<string, unknown>, schema: z.ZodTypeAny): Promise<ValidationResult>;
+    /**
+     * Validates a form
+     */
+    validateForm(config: FormWizardConfig, data: Record<string, unknown>): Promise<ValidationResult>;
+}