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

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


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


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


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

export function promiseMaybeArrayOfGreaterThanHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|((number)[])> {
    return (name : string, mixed : any) : Promise<null|undefined|((number)[])> => {
        return promiseMaybeArrayOfGreaterThan(name, mixed, x);
    };
}


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

export function promiseMaybeArrayOfGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|((number)[])> {
    return (name : string, mixed : any) : Promise<null|undefined|((number)[])> => {
        return promiseMaybeArrayOfGreaterThanOrEqual(name, mixed, x);
    };
}


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

export function promiseMaybeArrayOfLessThanHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|((number)[])> {
    return (name : string, mixed : any) : Promise<null|undefined|((number)[])> => {
        return promiseMaybeArrayOfLessThan(name, mixed, x);
    };
}


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

export function promiseMaybeArrayOfLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|((number)[])> {
    return (name : string, mixed : any) : Promise<null|undefined|((number)[])> => {
        return promiseMaybeArrayOfLessThanOrEqual(name, mixed, x);
    };
}


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

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


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


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


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


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


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


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


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

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


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


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