import { Connection } from "mysql";
import Model, { ModelType } from "./Model.js";
import ModelQuery from "./ModelQuery.js";
export declare const EMAIL_REGEX: RegExp;
export default class Validator<V> {
    static validate(validationMap: {
        [p: string]: Validator<unknown>;
    }, body: {
        [p: string]: unknown;
    }): Promise<void>;
    private readonly steps;
    private readonly validationAttributes;
    private readonly rawValueToHuman?;
    private _min?;
    private _max?;
    constructor(rawValueToHuman?: (val: V) => string);
    /**
     * @param thingName The name of the thing to validate.
     * @param value The value to verify.
     * @param onlyFormat {@code true} to only validate format properties, {@code false} otherwise.
     * @param connection A connection to use in case of wrapped transactions.
     */
    execute(thingName: string, value: V | undefined, onlyFormat: boolean, connection?: Connection): Promise<void>;
    defined(): Validator<V>;
    acceptUndefined(alsoAcceptEmptyString?: boolean): Validator<V>;
    equals(other?: V): Validator<V>;
    sameAs(otherName?: string, other?: V): Validator<V>;
    regexp(regexp: RegExp): Validator<V>;
    length(length: number): Validator<V>;
    /**
     * @param minLength included
     */
    minLength(minLength: number): Validator<V>;
    /**
     * @param maxLength included
     */
    maxLength(maxLength: number): Validator<V>;
    /**
     * @param minLength included
     * @param maxLength included
     */
    between(minLength: number, maxLength: number): Validator<V>;
    /**
     * @param min included
     */
    min(min: number): Validator<V>;
    /**
     * @param max included
     */
    max(max: number): Validator<V>;
    unique<M extends Model>(model: M | ModelType<M>, foreignKey?: string, querySupplier?: () => ModelQuery<M>): Validator<V>;
    exists(modelType: ModelType<Model>, foreignKey?: string): Validator<V>;
    private addStep;
    getValidationAttributes(): string[];
    step(step: number): Validator<V>;
}
export declare class ValidationBag<V> extends Error {
    private readonly errors;
    addMessage(err: ValidationError<V>): void;
    addBag(otherBag: ValidationBag<V>): void;
    hasMessages(): boolean;
    getMessages(): {
        [p: string]: ValidationError<V>;
    };
    getErrors(): ValidationError<V>[];
}
export declare class ValidationError<V> extends Error {
    rawValueToHuman?: (val: V) => string;
    thingName?: string;
    value?: V;
    get name(): string;
}
export declare class BadLengthValidationError<V> extends ValidationError<V> {
    private readonly expectedLength;
    private readonly maxLength?;
    constructor(expectedLength: number, maxLength?: number);
    get message(): string;
}
export declare class TooShortError<V> extends ValidationError<V> {
    private readonly minLength;
    constructor(minLength: number);
    get message(): string;
}
export declare class TooLongError<V> extends ValidationError<V> {
    private readonly maxLength;
    constructor(maxLength: number);
    get message(): string;
}
export declare class BadValueValidationError<V> extends ValidationError<V> {
    private readonly expectedValue;
    constructor(expectedValue: V);
    get message(): string;
}
export declare class DifferentThanError<V> extends ValidationError<V> {
    private readonly otherName?;
    constructor(otherName?: string);
    get message(): string;
}
export declare class OutOfRangeValidationError<V> extends ValidationError<V> {
    private readonly min?;
    private readonly max?;
    constructor(min?: number, max?: number);
    get message(): string;
}
export declare class InvalidFormatValidationError<V> extends ValidationError<V> {
    get message(): string;
}
export declare class UndefinedValueValidationError<V> extends ValidationError<V> {
    get message(): string;
}
export declare class AlreadyExistsValidationError<V> extends ValidationError<V> {
    private readonly table;
    constructor(table: string);
    get message(): string;
}
export declare class UnknownRelationValidationError<V> extends ValidationError<V> {
    private readonly table;
    private readonly foreignKey?;
    constructor(table: string, foreignKey?: string);
    get message(): string;
}
export declare class FileError<V> extends ValidationError<V> {
    private readonly _message;
    constructor(message: string);
    get message(): string;
}
export declare type Lengthable = {
    length: number;
};
export declare function isLenghtable(value: unknown): value is Lengthable;