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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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