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

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


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


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


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

export function assertMaybeGreaterThanHandler (x : number) : (name : string, mixed : any) => (null|undefined|(number))|never {
    return (name : string, mixed : any) : (null|undefined|(number))|never => {
        return assertMaybeGreaterThan(name, mixed, x);
    };
}


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

export function assertMaybeGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => (null|undefined|(number))|never {
    return (name : string, mixed : any) : (null|undefined|(number))|never => {
        return assertMaybeGreaterThanOrEqual(name, mixed, x);
    };
}


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

export function assertMaybeLessThanHandler (x : number) : (name : string, mixed : any) => (null|undefined|(number))|never {
    return (name : string, mixed : any) : (null|undefined|(number))|never => {
        return assertMaybeLessThan(name, mixed, x);
    };
}


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

export function assertMaybeLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => (null|undefined|(number))|never {
    return (name : string, mixed : any) : (null|undefined|(number))|never => {
        return assertMaybeLessThanOrEqual(name, mixed, x);
    };
}


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

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


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


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


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


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


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


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


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

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


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


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