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

export function promiseMaybePotentiallyUnsafeNumber (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybePotentiallyUnsafeNumber(name, mixed));
    });
}


export function promiseMaybeFiniteNumber (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeFiniteNumber(name, mixed));
    });
}


export function promiseMaybeInteger (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeInteger(name, mixed));
    });
}


export function promiseMaybeGreaterThan (name : string, mixed : any, x : number) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeGreaterThan(name, mixed, x));
    });
}

export function promiseMaybeGreaterThanHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|(number)> {
    return (name : string, mixed : any) : Promise<null|undefined|(number)> => {
        return promiseMaybeGreaterThan(name, mixed, x);
    };
}


export function promiseMaybeGreaterThanOrEqual (name : string, mixed : any, x : number) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeGreaterThanOrEqual(name, mixed, x));
    });
}

export function promiseMaybeGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|(number)> {
    return (name : string, mixed : any) : Promise<null|undefined|(number)> => {
        return promiseMaybeGreaterThanOrEqual(name, mixed, x);
    };
}


export function promiseMaybeLessThan (name : string, mixed : any, x : number) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeLessThan(name, mixed, x));
    });
}

export function promiseMaybeLessThanHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|(number)> {
    return (name : string, mixed : any) : Promise<null|undefined|(number)> => {
        return promiseMaybeLessThan(name, mixed, x);
    };
}


export function promiseMaybeLessThanOrEqual (name : string, mixed : any, x : number) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeLessThanOrEqual(name, mixed, x));
    });
}

export function promiseMaybeLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|(number)> {
    return (name : string, mixed : any) : Promise<null|undefined|(number)> => {
        return promiseMaybeLessThanOrEqual(name, mixed, x);
    };
}


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

export function promiseMaybeRangeHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<null|undefined|(number)> {
    return (name : string, mixed : any) : Promise<null|undefined|(number)> => {
        return promiseMaybeRange(name, mixed, args);
    };
}


export function promiseMaybePositive (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybePositive(name, mixed));
    });
}


export function promiseMaybeNegative (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeNegative(name, mixed));
    });
}


export function promiseMaybeNonNegative (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeNonNegative(name, mixed));
    });
}


export function promiseMaybeNaturalNumber (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeNaturalNumber(name, mixed));
    });
}


export function promiseMaybeOdd (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeOdd(name, mixed));
    });
}


export function promiseMaybeEven (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeEven(name, mixed));
    });
}


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

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


export function promiseMaybeLatitude (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeLatitude(name, mixed));
    });
}


export function promiseMaybeLongitude (name : string, mixed : any) : Promise<null|undefined|(number)> {
    return new Promise<null|undefined|(number)>((resolve) => {
        resolve(assert.assertMaybeLongitude(name, mixed));
    });
}