export interface ValidationSchema<T = any> {
    parse(input: unknown): T;
    safeParse(input: unknown): {
        success: true;
        data: T;
    } | {
        success: false;
        error: Error;
    };
}
export interface ValidationRule<T = any> {
    name: string;
    validate: (value: T) => boolean | Promise<boolean>;
    message: string;
    suggestion?: string;
}
export declare class Validator<T = any> implements ValidationSchema<T> {
    private typeName;
    private parseFunction?;
    private logger;
    private rules;
    constructor(typeName: string, parseFunction?: ((input: unknown) => T) | undefined);
    addRule(rule: ValidationRule<T>): this;
    required(message?: string): this;
    string(message?: string): this;
    number(message?: string): this;
    email(message?: string): this;
    url(message?: string): this;
    min(minValue: number, message?: string): this;
    max(maxValue: number, message?: string): this;
    oneOf<U extends T>(values: U[], message?: string): this;
    custom(name: string, validate: (value: T) => boolean | Promise<boolean>, message: string, suggestion?: string): this;
    parse(input: unknown): T;
    safeParse(input: unknown): {
        success: true;
        data: T;
    } | {
        success: false;
        error: Error;
    };
    safeParseAsync(input: unknown): Promise<{
        success: true;
        data: T;
    } | {
        success: false;
        error: Error;
    }>;
}
export declare const StringValidator: () => Validator<string>;
export declare const NumberValidator: () => Validator<number>;
export declare const EmailValidator: () => Validator<string>;
export declare const UrlValidator: () => Validator<string>;
export declare class ObjectValidator<T extends Record<string, any>> implements ValidationSchema<T> {
    private logger;
    private fieldValidators;
    private requiredFields;
    field<K extends keyof T>(key: K, validator: ValidationSchema<T[K]>, required?: boolean): this;
    parse(input: unknown): T;
    safeParse(input: unknown): {
        success: true;
        data: T;
    } | {
        success: false;
        error: Error;
    };
}
export declare class ArrayValidator<T> implements ValidationSchema<T[]> {
    private itemValidator;
    private minLength?;
    private maxLength?;
    private logger;
    constructor(itemValidator: ValidationSchema<T>, minLength?: number | undefined, maxLength?: number | undefined);
    parse(input: unknown): T[];
    safeParse(input: unknown): {
        success: true;
        data: T[];
    } | {
        success: false;
        error: Error;
    };
}
export declare class AgentValidator {
    private logger;
    static validateToolArgs<T>(validator: ValidationSchema<T>, args: unknown, toolName: string): T;
    static validateOutput<T>(validator: ValidationSchema<T>, output: unknown, retryCount?: number): T;
}
export declare function jsonSchemaToValidator(schema: any): ValidationSchema<any>;
//# sourceMappingURL=validation.d.ts.map