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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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