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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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