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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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