type Cleaner<T, V = any> = (value: V, context?: Record<string, any>) => T | PromiseLike<T>;

interface AnySchema<T, V = any> {
    /** `required: false` - allow undefined values */
    required?: boolean;
    /** `null: true` - allow null values */
    null?: boolean;
    /** Replace `undefined` with this value (sets `required: false` automatically) */
    default?: any;
    /** Override flat collector field label, or `null` to omit field label altogether. */
    label?: string | null;
    /** Nested cleaner (called if the validation passes) */
    clean?: Cleaner<T, V>;
}
type WithSchema<C extends Cleaner<any>, S> = C & {
    schema: S;
};
declare function setSchema<C extends Cleaner<any>, S>(fn: C, schema: S): WithSchema<C extends WithSchema<infer OC extends Cleaner<any, any>, any> ? OC : C, S>;
declare function cleanAny<T = any, V = any>(schema?: AnySchema<T, V>): WithSchema<Cleaner<T, V>, AnySchema<T, V>>;

interface ArraySchema<E, T> extends AnySchema<T, E[]> {
    /** Individual element cleaner. */
    element?: Cleaner<E>;
    /** Minimum allowed number of elements. */
    min?: number;
    /** Maximum allowed number of elements. */
    max?: number;
}
declare function cleanArray<E = any, T = E[], V = any>(schema?: ArraySchema<E, T>): WithSchema<Cleaner<T, V>, ArraySchema<E, T>>;

interface BooleanSchema<T> extends AnySchema<T, boolean> {
    /** No strict type check, convert value with `!!value` */
    cast?: boolean;
    /** Return `undefined` for `false` */
    omit?: boolean;
}
declare function cleanBoolean<T = boolean, V = any>(schema?: BooleanSchema<T>): WithSchema<Cleaner<T, V>, BooleanSchema<T>>;

interface StringSchema<T> extends AnySchema<T, string> {
    /**
     * `blank: true` - allow blank values (empty strings).
     *
     * `blank: null` - convert blank values (empty strings) to `null` (sets `null: true` automatically).
     */
    blank?: boolean | null;
    /** `cast: true` - no strict type check, convert value with `String(value)` */
    cast?: boolean;
    /** Test non-blank strings to match against regexp */
    regexp?: RegExp;
}
declare function cleanString<T = string, V = any>(schema?: StringSchema<T>): WithSchema<Cleaner<T, V>, StringSchema<T>>;

interface DateSchema<T> extends Omit<StringSchema<T>, "cast" | "regexp"> {
    /**
     * `format: undefined` (default) - return Date object
     *
     * `format: null` - return valid value as is
     *
     * `format: "iso"` - return ISO-formatted date-time
     */
    format?: null | "iso";
}
declare function cleanDate<T = Date, V = any>(schema?: DateSchema<T> & {
    format?: undefined;
}): Cleaner<T, V>;
declare function cleanDate<T = string, V = any>(schema?: DateSchema<T> & {
    format: "iso" | null;
}): Cleaner<T, V>;

type EmailSchema<T> = StringSchema<T>;
declare function cleanEmail<T = string, V = any>(schema?: EmailSchema<T>): WithSchema<Cleaner<T, V>, EmailSchema<T>>;

interface NumberSchema<T> extends AnySchema<T, number> {
    /** No strict type check, convert value with `parseInt(value)` */
    cast?: boolean;
    /** Minimum allowed value */
    min?: number;
    /** Maximum allowed value */
    max?: number;
    parseNumber: (value: any) => number;
}

type FloatSchema<T> = Omit<NumberSchema<T>, "parseNumber">;
declare function cleanFloat<T = number, V = any>(schema?: FloatSchema<T>): WithSchema<Cleaner<T, V>, FloatSchema<T>>;

type IntegerSchema<T> = Omit<NumberSchema<T>, "parseNumber">;
declare function cleanInteger<T = number, V = any>(schema?: IntegerSchema<T>): WithSchema<Cleaner<T, V>, IntegerSchema<T>>;

type ParseKeysOptions = boolean | ((key: string) => string[]);
interface ObjectSchema<M, T> extends AnySchema<T, M> {
    /** Create nested objects from keys like `job.position`
     *
     * `true`: split by dots
     *
     * `(string) => string[]`: custom key path parser function
     */
    parseKeys?: ParseKeysOptions;
    /** Map of field names to their respective cleaners */
    fields: {
        [F in keyof M]?: Cleaner<M[F]>;
    };
    /** Non-field errors will be grouped under this pseudo field key */
    nonFieldErrorsKey?: string;
    /** `groupErrors: true` (default) - group field errors by field name */
    groupErrors?: boolean;
}
declare function cleanObject<M extends Record<string, any>, T = M, V = any>(schema: ObjectSchema<M, T>): WithSchema<Cleaner<T, V>, ObjectSchema<M, T>>;
declare namespace cleanObject {
    var fields: <T extends Record<string, any>>(fields: { [F in keyof T]?: Cleaner<T[F], any> | undefined; }) => WithSchema<Cleaner<T, any>, ObjectSchema<T, T>>;
}

type UuidSchema<T> = Omit<StringSchema<T>, "regexp">;
declare function cleanUuid<T = string, V = any>(schema?: UuidSchema<T>): WithSchema<Cleaner<T, V>, UuidSchema<T>>;

type indexNs_AnySchema<T, V = any> = AnySchema<T, V>;
type indexNs_ArraySchema<E, T> = ArraySchema<E, T>;
type indexNs_BooleanSchema<T> = BooleanSchema<T>;
type indexNs_DateSchema<T> = DateSchema<T>;
type indexNs_EmailSchema<T> = EmailSchema<T>;
type indexNs_FloatSchema<T> = FloatSchema<T>;
type indexNs_IntegerSchema<T> = IntegerSchema<T>;
type indexNs_ObjectSchema<M, T> = ObjectSchema<M, T>;
type indexNs_StringSchema<T> = StringSchema<T>;
type indexNs_UuidSchema<T> = UuidSchema<T>;
declare namespace indexNs {
  export {
    cleanAny as any,
    indexNs_AnySchema as AnySchema,
    cleanArray as array,
    indexNs_ArraySchema as ArraySchema,
    cleanBoolean as boolean,
    indexNs_BooleanSchema as BooleanSchema,
    cleanDate as date,
    indexNs_DateSchema as DateSchema,
    cleanEmail as email,
    indexNs_EmailSchema as EmailSchema,
    cleanFloat as float,
    indexNs_FloatSchema as FloatSchema,
    cleanInteger as integer,
    indexNs_IntegerSchema as IntegerSchema,
    cleanObject as object,
    indexNs_ObjectSchema as ObjectSchema,
    cleanString as string,
    indexNs_StringSchema as StringSchema,
    cleanUuid as uuid,
    indexNs_UuidSchema as UuidSchema,
  };
}

declare class SchemaError extends Error {
}

type ErrorMessage = string;
type ErrorMessages = ErrorMessage[];
type FieldErrorMessages = {
    [field: string]: ErrorMessages;
};
type SimpleFieldErrorMessages = {
    [field: string]: ErrorMessage | ErrorMessages;
};
interface ErrorOptions {
    label?: string | null;
}
declare class ValidationError extends Error {
    messages?: ErrorMessages;
    errors?: FieldErrorMessages;
    opts: ErrorOptions;
    constructor(arg: ErrorMessage | ErrorMessages | SimpleFieldErrorMessages, opts?: Partial<ErrorOptions>);
}

export { AnySchema, ArraySchema, BooleanSchema, Cleaner, DateSchema, EmailSchema, ErrorMessage, ErrorMessages, ErrorOptions, FieldErrorMessages, FloatSchema, IntegerSchema, ObjectSchema, SchemaError, SimpleFieldErrorMessages, StringSchema, UuidSchema, ValidationError, WithSchema, cleanAny as any, cleanArray as array, cleanBoolean as boolean, indexNs as clean, cleanAny, cleanArray, cleanBoolean, cleanDate, cleanEmail, cleanFloat, cleanInteger, cleanObject, cleanString, cleanUuid, cleanDate as date, cleanEmail as email, cleanFloat as float, cleanInteger as integer, cleanObject as object, setSchema, cleanString as string, cleanUuid as uuid };