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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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