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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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