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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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