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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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