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

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


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


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


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

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


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

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


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

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


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

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


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

export function assertDictionaryOfMaybeArrayOfRangeStringHandler (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 assertDictionaryOfMaybeArrayOfRangeString(name, mixed, args);
    };
}


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


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


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


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


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


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


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

export function assertDictionaryOfMaybeArrayOfNotOneOfStringHandler<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 assertDictionaryOfMaybeArrayOfNotOneOfString(name, mixed, arr);
    };
}


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


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