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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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