import * as assert from "../../../../../main/generated/sync/assert/maybe/dictionary-of/number";

export function promiseMaybeDictionaryOfPotentiallyUnsafeNumber (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfPotentiallyUnsafeNumber(name, mixed));
    });
}


export function promiseMaybeDictionaryOfFiniteNumber (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfFiniteNumber(name, mixed));
    });
}


export function promiseMaybeDictionaryOfInteger (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfInteger(name, mixed));
    });
}


export function promiseMaybeDictionaryOfGreaterThan (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfGreaterThan(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfGreaterThanHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : number })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> => {
        return promiseMaybeDictionaryOfGreaterThan(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfGreaterThanOrEqual (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfGreaterThanOrEqual(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : number })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> => {
        return promiseMaybeDictionaryOfGreaterThanOrEqual(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfLessThan (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLessThan(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfLessThanHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : number })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> => {
        return promiseMaybeDictionaryOfLessThan(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfLessThanOrEqual (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLessThanOrEqual(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : number })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> => {
        return promiseMaybeDictionaryOfLessThanOrEqual(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfRange (name : string, mixed : any, args : { min? : number, max? : number }) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfRange(name, mixed, args));
    });
}

export function promiseMaybeDictionaryOfRangeHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : number })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> => {
        return promiseMaybeDictionaryOfRange(name, mixed, args);
    };
}


export function promiseMaybeDictionaryOfPositive (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfPositive(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNegative (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNegative(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNonNegative (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNonNegative(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNaturalNumber (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNaturalNumber(name, mixed));
    });
}


export function promiseMaybeDictionaryOfOdd (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfOdd(name, mixed));
    });
}


export function promiseMaybeDictionaryOfEven (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfEven(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNotOneOf<T extends number> (name : string, mixed : any, arr : T[]) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNotOneOf(name, mixed, arr));
    });
}

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


export function promiseMaybeDictionaryOfLatitude (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLatitude(name, mixed));
    });
}


export function promiseMaybeDictionaryOfLongitude (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : number })> {
    return new Promise<null|undefined|({ [key : string] : number })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLongitude(name, mixed));
    });
}