import * as check from "../../../../../generated/sync/check/maybe/array-of/date";
import {AssertError} from "../../../../../sync/error/AssertError";

export function assertMaybeArrayOfPotentiallyUnsafeDate (name : string, mixed : any) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfPotentiallyUnsafeDate(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertMaybeArrayOfValidDate (name : string, mixed : any) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfValidDate(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertMaybeArrayOfBefore (name : string, mixed : any, x : Date) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfBefore(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertMaybeArrayOfBeforeHandler (x : Date) : (name : string, mixed : any) => (null|undefined|((Date)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((Date)[]))|never => {
        return assertMaybeArrayOfBefore(name, mixed, x);
    };
}


export function assertMaybeArrayOfAfter (name : string, mixed : any, x : Date) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfAfter(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertMaybeArrayOfAfterHandler (x : Date) : (name : string, mixed : any) => (null|undefined|((Date)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((Date)[]))|never => {
        return assertMaybeArrayOfAfter(name, mixed, x);
    };
}


export function assertMaybeArrayOfBeforeOrAt (name : string, mixed : any, x : Date) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfBeforeOrAt(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertMaybeArrayOfBeforeOrAtHandler (x : Date) : (name : string, mixed : any) => (null|undefined|((Date)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((Date)[]))|never => {
        return assertMaybeArrayOfBeforeOrAt(name, mixed, x);
    };
}


export function assertMaybeArrayOfAfterOrAt (name : string, mixed : any, x : Date) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfAfterOrAt(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertMaybeArrayOfAfterOrAtHandler (x : Date) : (name : string, mixed : any) => (null|undefined|((Date)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((Date)[]))|never => {
        return assertMaybeArrayOfAfterOrAt(name, mixed, x);
    };
}


export function assertMaybeArrayOfRange (name : string, mixed : any, args : { min? : Date, max? : Date }) : (null|undefined|((Date)[]))|never {
    const error = check.checkMaybeArrayOfRange(mixed, args);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, args);
    }
}

export function assertMaybeArrayOfRangeHandler (args : { min? : Date, max? : Date }) : (name : string, mixed : any) => (null|undefined|((Date)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((Date)[]))|never => {
        return assertMaybeArrayOfRange(name, mixed, args);
    };
}