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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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