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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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