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

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


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


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

export function assertArrayOfBeforeHandler (x : Date) : (name : string, mixed : any) => ((Date)[])|never {
    return (name : string, mixed : any) : ((Date)[])|never => {
        return assertArrayOfBefore(name, mixed, x);
    };
}


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

export function assertArrayOfAfterHandler (x : Date) : (name : string, mixed : any) => ((Date)[])|never {
    return (name : string, mixed : any) : ((Date)[])|never => {
        return assertArrayOfAfter(name, mixed, x);
    };
}


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

export function assertArrayOfBeforeOrAtHandler (x : Date) : (name : string, mixed : any) => ((Date)[])|never {
    return (name : string, mixed : any) : ((Date)[])|never => {
        return assertArrayOfBeforeOrAt(name, mixed, x);
    };
}


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

export function assertArrayOfAfterOrAtHandler (x : Date) : (name : string, mixed : any) => ((Date)[])|never {
    return (name : string, mixed : any) : ((Date)[])|never => {
        return assertArrayOfAfterOrAt(name, mixed, x);
    };
}


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

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