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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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