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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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