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

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


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


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


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

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


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

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


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

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


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

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


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

export function assertMaybeDictionaryOfArrayOfRangeHandler (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 assertMaybeDictionaryOfArrayOfRange(name, mixed, args);
    };
}


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


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


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


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


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


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


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

export function assertMaybeDictionaryOfArrayOfNotOneOfHandler<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 assertMaybeDictionaryOfArrayOfNotOneOf(name, mixed, arr);
    };
}


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


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