import { z, ZodSchema, ZodError, ZodType } from 'zod';
/**
 * Validation result structure
 */
export interface ValidationResult<T = unknown> {
    success: boolean;
    data?: T;
    errors?: FormattedValidationError[];
}
/**
 * Formatted validation error for UI display
 */
export interface FormattedValidationError {
    path: string;
    message: string;
    code: string;
    params?: Record<string, unknown>;
}
/**
 * Custom validator function
 */
export type CustomValidator<T = unknown> = (value: T, context?: ValidationContext) => Promise<ValidationResult<T>> | ValidationResult<T>;
/**
 * Validation context for custom validators
 */
export interface ValidationContext {
    path: string[];
    data: Record<string, unknown>;
    abortSignal?: AbortSignal;
}
/**
 * Form field state
 */
export interface FieldState<T = unknown> {
    value: T;
    error?: string;
    touched: boolean;
    dirty: boolean;
    validating: boolean;
}
/**
 * Form validation options
 */
export interface FormValidationOptions {
    mode?: 'onChange' | 'onBlur' | 'onSubmit';
    revalidateMode?: 'onChange' | 'onBlur';
    shouldFocusError?: boolean;
    criteriaMode?: 'firstError' | 'all';
}
/**
 * State validation configuration
 */
export interface StateValidationConfig {
    schema: ZodSchema;
    onError?: (errors: FormattedValidationError[]) => void;
    strict?: boolean;
}
/**
 * Format Zod errors for UI display
 */
export declare function formatZodErrors(error: ZodError): FormattedValidationError[];
/**
 * Format errors for React Hook Form
 */
export declare function formatErrorsForForm(errors: FormattedValidationError[]): Record<string, {
    message: string;
}>;
/**
 * Get first error message for a field
 */
export declare function getFieldError(errors: FormattedValidationError[], fieldPath: string): string | undefined;
/**
 * Group errors by field path
 */
export declare function groupErrorsByField(errors: FormattedValidationError[]): Record<string, FormattedValidationError[]>;
/**
 * Validate data against a registered schema
 */
export declare function validateWithSchema<T>(schemaName: string, data: unknown, options?: {
    useCache?: boolean;
    abortSignal?: AbortSignal;
}): Promise<ValidationResult<T>>;
/**
 * Validate data with direct schema
 */
export declare function validate<T>(schema: ZodSchema<T>, data: unknown): Promise<ValidationResult<T>>;
/**
 * Validate API response
 */
export declare function validateApiResponse<T>(schema: ZodSchema<T>, response: unknown, options?: {
    strict?: boolean;
}): Promise<ValidationResult<T>>;
/**
 * Validate state change
 */
export declare function validateStateChange<T>(currentState: T, updates: Partial<T>, schema: ZodSchema<T>): ValidationResult<T>;
/**
 * Form validation hook with comprehensive field management
 */
export declare function useFormValidation<T extends Record<string, unknown>>(schema: ZodSchema<T>, options?: FormValidationOptions): {
    values: Partial<T>;
    errors: Record<string, string>;
    touched: Record<string, boolean>;
    isSubmitting: boolean;
    isValidating: boolean;
    submitCount: number;
    isValid: boolean;
    setValue: (name: keyof T, value: unknown) => void;
    setFieldValues: (updates: Partial<T>) => void;
    handleBlur: (name: keyof T) => void;
    handleSubmit: (onSubmit: (data: T) => void | Promise<void>) => (e?: React.FormEvent) => Promise<void>;
    validateForm: (data: Partial<T>) => Promise<boolean>;
    validateField: (name: keyof T, value: unknown) => Promise<boolean>;
    reset: (newValues?: Partial<T>) => void;
    register: (name: keyof T) => {
        name: string;
        value: string | NonNullable<Partial<T>[keyof T]>;
        onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
        onBlur: () => void;
        error: string | undefined;
        touched: boolean;
    };
};
/**
 * Single field validation hook
 */
export declare function useFieldValidation<T>(_name: string, schema: ZodType<T>, options?: {
    defaultValue?: T;
    validateOn?: 'change' | 'blur' | 'both';
    debounceMs?: number;
}): {
    value: T | undefined;
    error: string | undefined;
    touched: boolean;
    validating: boolean;
    setValue: (newValue: T) => void;
    onBlur: () => void;
    reset: () => void;
};
/**
 * Create async validator with debouncing
 */
export declare function createAsyncValidator<T>(validatorFn: (value: T) => Promise<boolean | string>, options?: {
    debounceMs?: number;
    cacheResults?: boolean;
}): (value: T) => Promise<ValidationResult<T>>;
/**
 * Check uniqueness (e.g., email, username)
 */
export declare function createUniquenessValidator<T>(checkFn: (value: T) => Promise<boolean>, message?: string): CustomValidator<T>;
/**
 * Common validation schemas
 */
export declare const commonSchemas: {
    email: z.ZodString;
    password: z.ZodString;
    url: z.ZodString;
    uuid: z.ZodString;
    phone: z.ZodString;
    zipCode: z.ZodString;
    slug: z.ZodString;
    username: z.ZodString;
    positiveNumber: z.ZodNumber;
    percentage: z.ZodNumber;
    dateString: z.ZodString;
};
/**
 * Enzyme Validation Extension
 */
export declare const validationExtension: {
    name: string;
    version: string;
    description: string;
    client: {
        /**
         * Register a named schema
         */
        $registerSchema(name: string, schema: ZodSchema, metadata?: {
            description?: string;
            version?: string;
        }): void;
        /**
         * Validate data against registered schema
         */
        $validate<T>(schemaName: string, data: unknown, options?: {
            useCache?: boolean;
        }): Promise<ValidationResult<T>>;
        /**
         * Validate with direct schema
         */
        $validateAsync<T>(schema: ZodSchema<T>, data: unknown): Promise<ValidationResult<T>>;
        /**
         * Get validation errors formatted for display
         */
        $getValidationErrors(result: ValidationResult): FormattedValidationError[];
        /**
         * Format errors for form display
         */
        $formatErrorsForForm(errors: FormattedValidationError[]): Record<string, {
            message: string;
        }>;
        /**
         * Create form validator
         */
        $createFormValidator<T extends Record<string, unknown>>(schema: ZodSchema<T>, options?: FormValidationOptions): {
            schema: z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>;
            options: FormValidationOptions | undefined;
            validate: (data: Partial<T>) => Promise<ValidationResult<T>>;
        };
        /**
         * Add custom validator
         */
        $addCustomValidator<T = unknown>(name: string, validator: CustomValidator<T>): void;
        /**
         * Execute custom validator
         */
        $executeValidator<T>(name: string, value: T, context?: ValidationContext): Promise<ValidationResult<T>>;
        /**
         * Validate API response
         */
        $validateApiResponse<T>(schema: ZodSchema<T>, response: unknown, options?: {
            strict?: boolean;
        }): Promise<ValidationResult<T>>;
        /**
         * Validate state change
         */
        $validateStateChange<T>(currentState: T, updates: Partial<T>, schema: ZodSchema<T>): ValidationResult<T>;
        /**
         * Configure validation cache
         */
        $configureCache(options: {
            maxSize?: number;
            ttl?: number;
        }): void;
        /**
         * Clear validation cache
         */
        $clearCache(): void;
        /**
         * Get registered schemas
         */
        $listSchemas(): string[];
        /**
         * Get schema by name
         */
        $getSchema(name: string): ZodSchema | undefined;
        /**
         * Common validation schemas
         */
        $commonSchemas: {
            email: z.ZodString;
            password: z.ZodString;
            url: z.ZodString;
            uuid: z.ZodString;
            phone: z.ZodString;
            zipCode: z.ZodString;
            slug: z.ZodString;
            username: z.ZodString;
            positiveNumber: z.ZodNumber;
            percentage: z.ZodNumber;
            dateString: z.ZodString;
        };
    };
};
export default validationExtension;