import type { ValidateFunction } from 'ajv/dist/2020.js';
import { FormError } from '../utils';
import type { AjvInstance } from '../utils/ajv';
import type * as z from 'zod';
import type { FieldPropsGeneric, ReceiveAdditionalEventArgs, Validator, Identifier } from '../types';
import type { TransformerFns } from './useFieldTransform';
import type { SubmitStateWithValidating, PersistErrorStateMethod, ErrorInitiator } from './useFieldError';
import type { AsyncProcesses } from './useFieldAsync';
export type UseFieldValidationParams<Value> = {
    finalSchema: unknown;
    hasZodSchema: boolean;
    onChangeValidatorProp: Validator<Value>;
    onBlurValidator: Validator<Value>;
    validateInitially: boolean;
    validateUnchanged: boolean;
    validateContinuously: boolean;
    identifier: Identifier;
    disabled: boolean;
    emptyValue: unknown;
    required: boolean;
    hasDataContext: boolean;
    getAjvInstanceDataContext: () => AjvInstance;
    setFieldEventListener: (identifier: Identifier, event: string, fn: () => void) => void;
    getValueByPath: (path: string) => unknown;
    getSourceValue: (path: string) => unknown;
    exportValidators: unknown;
    props: unknown;
    dataContext: unknown;
    combinedErrorMessages: Record<string, string>;
    makeIteratePath: (path: string, suffix?: string, options?: unknown) => string;
    errorPrioritization: string[];
    sectionPath: string;
    hasSectionSchema: boolean;
    dataContextSchema: unknown;
    valueRef: React.RefObject<Value>;
    changedRef: React.RefObject<boolean>;
    transformers: React.RefObject<TransformerFns<Value>>;
    schemaValidatorRef: React.RefObject<ValidateFunction | ((value: unknown) => true | z.ZodError<unknown>)>;
    asyncProcessRef: React.RefObject<AsyncProcesses | null>;
    validatedValueRef: React.RefObject<Value>;
    changeEventResultRef: React.RefObject<unknown>;
    localErrorInitiatorRef: React.RefObject<ErrorInitiator>;
    error: FieldPropsGeneric<Value>['error'];
    persistErrorState: (method: PersistErrorStateMethod, initiator: ErrorInitiator, error?: Error | FormError | Array<Error | FormError>) => void;
    clearErrorState: () => void;
    revealError: () => void;
    hideError: () => void;
    setFieldState: (state: SubmitStateWithValidating) => void;
    ensureErrorMessageObject: <T>(error: T) => T;
    asyncBehaviorIsEnabled: boolean;
    defineAsyncProcess: (name: AsyncProcesses) => void;
    forceUpdate: () => void;
    revealErrorRef: React.RefObject<boolean | null>;
};
export default function useFieldValidation<Value>({ finalSchema, hasZodSchema, onChangeValidatorProp, onBlurValidator, validateInitially, validateUnchanged, validateContinuously, identifier, disabled, emptyValue, required, hasDataContext, getAjvInstanceDataContext, setFieldEventListener, getValueByPath, getSourceValue, exportValidators, props, dataContext, combinedErrorMessages, makeIteratePath, errorPrioritization, sectionPath, hasSectionSchema, dataContextSchema, valueRef, changedRef, transformers, schemaValidatorRef, asyncProcessRef, validatedValueRef, changeEventResultRef, localErrorInitiatorRef, error, persistErrorState, clearErrorState, revealError, hideError, setFieldState, ensureErrorMessageObject, asyncBehaviorIsEnabled, defineAsyncProcess, forceUpdate, revealErrorRef, }: UseFieldValidationParams<Value>): {
    validateValue: () => Promise<any>;
    startOnChangeValidatorValidation: () => Promise<{
        result: string | void | Error | (Error | FormError)[] | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Validator<Value, import("../types").DefaultErrorMessages>[];
    }>;
    startOnBlurValidatorProcess: ({ overrideValue, }?: {
        overrideValue?: Value;
    }) => Promise<{
        result: string | void | Error | (Error | FormError)[] | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Validator<Value, import("../types").DefaultErrorMessages>[];
    }>;
    runOnChangeValidator: () => Promise<any>;
    runOnBlurValidator: () => Promise<any>;
    callOnBlurValidator: ({ overrideValue, }?: {
        overrideValue?: Value;
    }) => Promise<{
        result?: undefined;
    } | {
        result: string | void | Error | (Error | FormError)[] | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Validator<Value, import("../types").DefaultErrorMessages>[];
    }>;
    handleConnectWithPath: (path: Identifier) => {
        getValue: () => unknown;
    };
    onChangeValidator: Validator<Value>;
    onChangeValidatorRef: import("react").RefObject<Validator<Value>>;
    onBlurValidatorRef: import("react").RefObject<Validator<Value>>;
    additionalArgs: ReceiveAdditionalEventArgs<Value>;
};