import { Schema, ValidationResult, ValidationIssue } from '../validation/schema-validator';
/**
 * Validation mode
 */
export type ValidationMode = 'onChange' | 'onBlur' | 'onSubmit' | 'all';
/**
 * Field error state
 */
export interface FieldErrors {
    [field: string]: string[];
}
/**
 * Validation state
 */
export interface ValidationState<T> {
    /** Whether validation has been performed */
    isDirty: boolean;
    /** Whether validation is in progress */
    isValidating: boolean;
    /** Whether data is valid */
    isValid: boolean;
    /** Last validated data */
    lastValidatedData: T | null;
    /** Validation errors */
    errors: ValidationIssue[];
    /** Field-level errors */
    fieldErrors: FieldErrors;
    /** Timestamp of last validation */
    lastValidatedAt: number | null;
}
/**
 * Validation hook options
 */
export interface UseDataValidationOptions<T> {
    /** Initial data */
    initialData?: T;
    /** Validation mode */
    mode?: ValidationMode;
    /** Debounce delay in ms */
    debounceMs?: number;
    /** Custom field extraction */
    getFieldValue?: (data: T, field: string) => unknown;
    /** Transform before validation */
    transformBeforeValidation?: (data: T) => T;
    /** Callback on validation success */
    onValid?: (data: T) => void;
    /** Callback on validation failure */
    onInvalid?: (errors: ValidationIssue[]) => void;
}
/**
 * Validation hook return type
 */
export interface UseDataValidationReturn<T> {
    /** Validate data */
    validate: (data: T) => ValidationResult<T>;
    /** Validate asynchronously */
    validateAsync: (data: T) => Promise<ValidationResult<T>>;
    /** Validate single field */
    validateField: (field: string, value: unknown) => ValidationResult<unknown>;
    /** Clear validation state */
    clearValidation: () => void;
    /** Reset to initial state */
    reset: () => void;
    /** Current validation state */
    state: ValidationState<T>;
    /** Whether data is valid */
    isValid: boolean;
    /** Whether validation is dirty */
    isDirty: boolean;
    /** Whether validating */
    isValidating: boolean;
    /** All errors */
    errors: ValidationIssue[];
    /** Field errors */
    fieldErrors: FieldErrors;
    /** Get errors for specific field */
    getFieldErrors: (field: string) => string[];
    /** Check if field has errors */
    hasFieldError: (field: string) => boolean;
    /** Touch a field (mark as dirty) */
    touchField: (field: string) => void;
    /** Touched fields */
    touchedFields: Set<string>;
}
/**
 * Hook for data validation
 *
 * @param schema - Validation schema
 * @param options - Hook options
 * @returns Validation state and methods
 */
export declare function useDataValidation<T>(schema: Schema<T>, options?: UseDataValidationOptions<T>): UseDataValidationReturn<T>;
/**
 * Hook for validating data on change with debouncing
 *
 * @param schema - Validation schema
 * @param data - Data to validate
 * @param debounceMs - Debounce delay
 * @returns Validation state
 */
export declare function useValidateOnChange<T>(schema: Schema<T>, data: T, debounceMs?: number): {
    isValid: boolean;
    errors: ValidationIssue[];
    isValidating: boolean;
};
/**
 * Hook for validating a single value
 *
 * @param schema - Validation schema
 * @param value - Value to validate
 * @returns Validation result
 */
export declare function useValidateValue<T>(schema: Schema<T>, value: T): {
    isValid: boolean;
    error: string | null;
};
/**
 * Hook for async validation
 *
 * @param validateFn - Async validation function
 * @param data - Data to validate
 * @param deps - Dependencies to trigger re-validation
 * @returns Validation state
 */
export declare function useAsyncValidation<T>(validateFn: (data: T) => Promise<ValidationResult<T>>, data: T, deps?: unknown[]): {
    isValid: boolean | null;
    isValidating: boolean;
    errors: ValidationIssue[];
    validate: () => Promise<ValidationResult<T>>;
};