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

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


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


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


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

export function assertArrayOfGreaterThanHandler (x : number) : (name : string, mixed : any) => ((number)[])|never {
    return (name : string, mixed : any) : ((number)[])|never => {
        return assertArrayOfGreaterThan(name, mixed, x);
    };
}


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

export function assertArrayOfGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => ((number)[])|never {
    return (name : string, mixed : any) : ((number)[])|never => {
        return assertArrayOfGreaterThanOrEqual(name, mixed, x);
    };
}


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

export function assertArrayOfLessThanHandler (x : number) : (name : string, mixed : any) => ((number)[])|never {
    return (name : string, mixed : any) : ((number)[])|never => {
        return assertArrayOfLessThan(name, mixed, x);
    };
}


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

export function assertArrayOfLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => ((number)[])|never {
    return (name : string, mixed : any) : ((number)[])|never => {
        return assertArrayOfLessThanOrEqual(name, mixed, x);
    };
}


export function assertArrayOfRange (name : string, mixed : any, args : { min? : number, max? : number }) : ((number)[])|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? : number, max? : number }) : (name : string, mixed : any) => ((number)[])|never {
    return (name : string, mixed : any) : ((number)[])|never => {
        return assertArrayOfRange(name, mixed, args);
    };
}


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


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


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


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


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


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


export function assertArrayOfNotOneOf<T extends number> (name : string, mixed : any, arr : T[]) : ((number)[])|never {
    const error = check.checkArrayOfNotOneOf(mixed, arr);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, arr);
    }
}

export function assertArrayOfNotOneOfHandler<T extends number> (arr : T[]) : (name : string, mixed : any) => ((number)[])|never {
    return (name : string, mixed : any) : ((number)[])|never => {
        return assertArrayOfNotOneOf(name, mixed, arr);
    };
}


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


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