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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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