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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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