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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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