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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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