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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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