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

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


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


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


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

export function assertMaybeArrayOfGreaterThanHandler (x : number) : (name : string, mixed : any) => (null|undefined|((number)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((number)[]))|never => {
        return assertMaybeArrayOfGreaterThan(name, mixed, x);
    };
}


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

export function assertMaybeArrayOfGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => (null|undefined|((number)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((number)[]))|never => {
        return assertMaybeArrayOfGreaterThanOrEqual(name, mixed, x);
    };
}


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

export function assertMaybeArrayOfLessThanHandler (x : number) : (name : string, mixed : any) => (null|undefined|((number)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((number)[]))|never => {
        return assertMaybeArrayOfLessThan(name, mixed, x);
    };
}


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

export function assertMaybeArrayOfLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => (null|undefined|((number)[]))|never {
    return (name : string, mixed : any) : (null|undefined|((number)[]))|never => {
        return assertMaybeArrayOfLessThanOrEqual(name, mixed, x);
    };
}


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


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


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


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


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


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


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


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

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


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


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