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

export function promisePotentiallyUnsafeNumber (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertPotentiallyUnsafeNumber(name, mixed));
    });
}


export function promiseFiniteNumber (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertFiniteNumber(name, mixed));
    });
}


export function promiseInteger (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertInteger(name, mixed));
    });
}


export function promiseGreaterThan (name : string, mixed : any, x : number) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertGreaterThan(name, mixed, x));
    });
}

export function promiseGreaterThanHandler (x : number) : (name : string, mixed : any) => Promise<number> {
    return (name : string, mixed : any) : Promise<number> => {
        return promiseGreaterThan(name, mixed, x);
    };
}


export function promiseGreaterThanOrEqual (name : string, mixed : any, x : number) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertGreaterThanOrEqual(name, mixed, x));
    });
}

export function promiseGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<number> {
    return (name : string, mixed : any) : Promise<number> => {
        return promiseGreaterThanOrEqual(name, mixed, x);
    };
}


export function promiseLessThan (name : string, mixed : any, x : number) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertLessThan(name, mixed, x));
    });
}

export function promiseLessThanHandler (x : number) : (name : string, mixed : any) => Promise<number> {
    return (name : string, mixed : any) : Promise<number> => {
        return promiseLessThan(name, mixed, x);
    };
}


export function promiseLessThanOrEqual (name : string, mixed : any, x : number) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertLessThanOrEqual(name, mixed, x));
    });
}

export function promiseLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<number> {
    return (name : string, mixed : any) : Promise<number> => {
        return promiseLessThanOrEqual(name, mixed, x);
    };
}


export function promiseRange (name : string, mixed : any, args : { min? : number, max? : number }) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertRange(name, mixed, args));
    });
}

export function promiseRangeHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<number> {
    return (name : string, mixed : any) : Promise<number> => {
        return promiseRange(name, mixed, args);
    };
}


export function promisePositive (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertPositive(name, mixed));
    });
}


export function promiseNegative (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertNegative(name, mixed));
    });
}


export function promiseNonNegative (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertNonNegative(name, mixed));
    });
}


export function promiseNaturalNumber (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertNaturalNumber(name, mixed));
    });
}


export function promiseOdd (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertOdd(name, mixed));
    });
}


export function promiseEven (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertEven(name, mixed));
    });
}


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

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


export function promiseLatitude (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertLatitude(name, mixed));
    });
}


export function promiseLongitude (name : string, mixed : any) : Promise<number> {
    return new Promise<number>((resolve) => {
        resolve(assert.assertLongitude(name, mixed));
    });
}