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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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