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

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


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


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


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

export function assertDictionaryOfArrayOfGreaterThanStringHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (string)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (string)[] })|never => {
        return assertDictionaryOfArrayOfGreaterThanString(name, mixed, x);
    };
}


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

export function assertDictionaryOfArrayOfGreaterThanOrEqualStringHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (string)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (string)[] })|never => {
        return assertDictionaryOfArrayOfGreaterThanOrEqualString(name, mixed, x);
    };
}


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

export function assertDictionaryOfArrayOfLessThanStringHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (string)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (string)[] })|never => {
        return assertDictionaryOfArrayOfLessThanString(name, mixed, x);
    };
}


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

export function assertDictionaryOfArrayOfLessThanOrEqualStringHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (string)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (string)[] })|never => {
        return assertDictionaryOfArrayOfLessThanOrEqualString(name, mixed, x);
    };
}


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

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


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


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


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


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


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


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


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

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


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


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