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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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