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

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


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


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


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

export function assertDictionaryOfArrayOfGreaterThanHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (number)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (number)[] })|never => {
        return assertDictionaryOfArrayOfGreaterThan(name, mixed, x);
    };
}


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

export function assertDictionaryOfArrayOfGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (number)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (number)[] })|never => {
        return assertDictionaryOfArrayOfGreaterThanOrEqual(name, mixed, x);
    };
}


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

export function assertDictionaryOfArrayOfLessThanHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (number)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (number)[] })|never => {
        return assertDictionaryOfArrayOfLessThan(name, mixed, x);
    };
}


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

export function assertDictionaryOfArrayOfLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => ({ [key : string] : (number)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (number)[] })|never => {
        return assertDictionaryOfArrayOfLessThanOrEqual(name, mixed, x);
    };
}


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

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


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


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


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


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


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


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


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

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


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


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