import { Validated, CombinedValidated, ValueOfValidated, ErrorOfValidated } from './Validated';
import { IsUndefined } from './Undefineds';
export declare class ValidationRule<P, E, A = P, M extends any[] = []> {
    readonly apply: (p: P, ...meta: M) => Validated<E, A>;
    static compose<E, F, A, B, C, M extends any[]>(left: ValidationRule<A, E, B, M>, right: ValidationRule<B, F, C, M>): ValidationRule<A, E | F, C, M>;
    static combine<O extends {
        [k: string]: ValidationRule<any, any, any, any>;
    }>(o: O): ValidationRule<ParameterOfCombinedValidationRule<O>, ErrorOfValidated<CombinedValidated<ValidatedOfCombinedValidationRule<O>>>, ValueOfValidated<CombinedValidated<ValidatedOfCombinedValidationRule<O>>>, MetaOfCombinedValidationRule<O>>;
    static test<P, E, M extends any[] = []>(predicate: (p: P, ...meta: M) => Validated<E, []>): ValidationRule<P, E, P, M>;
    static create<P, E, A = P, M extends any[] = []>(apply: (p: P, ...meta: M) => Validated<E, A>): ValidationRule<P, E, A, M>;
    constructor(apply: (p: P, ...meta: M) => Validated<E, A>);
    map<B>(fn: (a: A) => B): ValidationRule<P, E, B, M>;
    mapError<F>(fn: (e: E) => F): ValidationRule<P, F, A, M>;
    composeWith<F, C>(other: ValidationRule<A, F, C, M>): ValidationRule<P, E | F, C, M>;
    filter<F>(pred: (a: A) => boolean, toError: (error: A) => F): ValidationRule<P, E | F, A, M>;
    recover<B>(f: (error: E) => B): ValidationRule<P, never, A | B, M>;
    orElse<Q, F, B>(alternative: ValidationRule<P, F, B, M>): ValidationRule<P & Q, F, A | B, M>;
    mapMeta<MM extends any[]>(fn: (mm: MM) => M): ValidationRule<P, E, A, MM>;
    mapInput<Q>(fn: (q: Q) => P): ValidationRule<Q, E, A, M>;
    upcastMeta<MM extends M>(): ValidationRule<P, E, A, MM>;
    required(): ValidationRule<P | undefined, E | IsUndefined, A, M>;
    optional(): ValidationRule<P | undefined, E, A | undefined, M>;
    many(): ValidationRule<P[], Partial<E[]>, A[], M>;
    of<F, B, C>(this: ValidationRule<P, E, B[], M>, validationRule: ValidationRule<B, F, C, M>): ValidationRule<P, E | Partial<F[]>, C[], M>;
    test<F>(...validationRules: Array<ValidationRule<A, F, A, M>>): ValidationRule<P, E | F[], A, M>;
}
declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
declare type ParameterOfValidationRule<V> = V extends ValidationRule<infer P, any, any, any> ? P : never;
declare type ParameterOfCombinedValidationRule<O> = {
    [K in keyof O]: ParameterOfValidationRule<O[K]>;
};
declare type MetaOfValidationRule<V> = V extends ValidationRule<any, any, any, infer M> ? M : never;
declare type MetaOfCombinedValidationRule<O> = UnionToIntersection<({
    [K in keyof O]: MetaOfValidationRule<O[K]>;
})[keyof O]> & any[];
declare type ErrorOfValidationRule<V> = V extends ValidationRule<any, infer E, any, any> ? E : never;
declare type ValueOfValidationRule<V> = V extends ValidationRule<any, any, infer A, any> ? A : never;
declare type ValidatedOfCombinedValidationRule<O> = {
    [K in keyof O]: Validated<ErrorOfValidationRule<O[K]>, ValueOfValidationRule<O[K]>>;
};
export {};