import { AbstractValidator } from '../types';
import type { InferInput, InferValidation, Validation, ValidationOptions, Validator } from '../types';
/** Constraints to validate an `Array` with. */
export interface ArrayConstraints<V extends Validation> {
    /** The _maximum_ number of elements a valid `Array`: `value.length <= maxItems` */
    maxItems?: number;
    /** The _minimum_ number of elements a valid `Array`: `value.length >= minItems` */
    minItems?: number;
    /** A flag indicating whether an `Array`'s elements must be unique */
    uniqueItems?: boolean;
    /** A `Validator` validating each individual item in an `Array` */
    items?: V;
}
/** Basic validator for `Array` instances. */
export declare class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
    validate(value: unknown): T[];
}
/** A validator for `Array` instances with constraints. */
export declare class ArrayValidator<T, I = T> extends AbstractValidator<T[], I[]> {
    readonly maxItems: number;
    readonly minItems: number;
    readonly uniqueItems: boolean;
    readonly items: Validator<T>;
    constructor(options?: ArrayConstraints<Validator<T>>);
    validate(value: unknown, options?: ValidationOptions): T[];
}
export declare function arrayValidatorFactory<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>, InferInput<V>>;
/** Validate `Array`s. */
export declare const array: typeof arrayValidatorFactory & AnyArrayValidator<any>;
/** Validate `Array`s containing only the specified elements. */
export declare function arrayOf<V extends Validation>(validation: V): Validator<InferValidation<V>[], InferInput<V>[]>;