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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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