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

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


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


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


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

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


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

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


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

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


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

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


export function promiseMaybeArrayOfDictionaryOfRange (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.assertMaybeArrayOfDictionaryOfRange(name, mixed, args));
    });
}

export function promiseMaybeArrayOfDictionaryOfRangeHandler (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 promiseMaybeArrayOfDictionaryOfRange(name, mixed, args);
    };
}


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


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


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


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


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


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


export function promiseMaybeArrayOfDictionaryOfNotOneOf<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.assertMaybeArrayOfDictionaryOfNotOneOf(name, mixed, arr));
    });
}

export function promiseMaybeArrayOfDictionaryOfNotOneOfHandler<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 promiseMaybeArrayOfDictionaryOfNotOneOf(name, mixed, arr);
    };
}


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


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