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

export function promiseDictionaryOfPotentiallyUnsafeNumber (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfPotentiallyUnsafeNumber(name, mixed));
    });
}


export function promiseDictionaryOfFiniteNumber (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfFiniteNumber(name, mixed));
    });
}


export function promiseDictionaryOfInteger (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfInteger(name, mixed));
    });
}


export function promiseDictionaryOfGreaterThan (name : string, mixed : any, x : number) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfGreaterThan(name, mixed, x));
    });
}

export function promiseDictionaryOfGreaterThanHandler (x : number) : (name : string, mixed : any) => Promise<{ [key : string] : number }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : number }> => {
        return promiseDictionaryOfGreaterThan(name, mixed, x);
    };
}


export function promiseDictionaryOfGreaterThanOrEqual (name : string, mixed : any, x : number) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfGreaterThanOrEqual(name, mixed, x));
    });
}

export function promiseDictionaryOfGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<{ [key : string] : number }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : number }> => {
        return promiseDictionaryOfGreaterThanOrEqual(name, mixed, x);
    };
}


export function promiseDictionaryOfLessThan (name : string, mixed : any, x : number) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfLessThan(name, mixed, x));
    });
}

export function promiseDictionaryOfLessThanHandler (x : number) : (name : string, mixed : any) => Promise<{ [key : string] : number }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : number }> => {
        return promiseDictionaryOfLessThan(name, mixed, x);
    };
}


export function promiseDictionaryOfLessThanOrEqual (name : string, mixed : any, x : number) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfLessThanOrEqual(name, mixed, x));
    });
}

export function promiseDictionaryOfLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<{ [key : string] : number }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : number }> => {
        return promiseDictionaryOfLessThanOrEqual(name, mixed, x);
    };
}


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

export function promiseDictionaryOfRangeHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<{ [key : string] : number }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : number }> => {
        return promiseDictionaryOfRange(name, mixed, args);
    };
}


export function promiseDictionaryOfPositive (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfPositive(name, mixed));
    });
}


export function promiseDictionaryOfNegative (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfNegative(name, mixed));
    });
}


export function promiseDictionaryOfNonNegative (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfNonNegative(name, mixed));
    });
}


export function promiseDictionaryOfNaturalNumber (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfNaturalNumber(name, mixed));
    });
}


export function promiseDictionaryOfOdd (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfOdd(name, mixed));
    });
}


export function promiseDictionaryOfEven (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfEven(name, mixed));
    });
}


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

export function promiseDictionaryOfNotOneOfHandler<T extends number> (arr : T[]) : (name : string, mixed : any) => Promise<{ [key : string] : number }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : number }> => {
        return promiseDictionaryOfNotOneOf(name, mixed, arr);
    };
}


export function promiseDictionaryOfLatitude (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfLatitude(name, mixed));
    });
}


export function promiseDictionaryOfLongitude (name : string, mixed : any) : Promise<{ [key : string] : number }> {
    return new Promise<{ [key : string] : number }>((resolve) => {
        resolve(assert.assertDictionaryOfLongitude(name, mixed));
    });
}