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

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


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


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


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

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


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

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


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

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


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

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


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

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


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


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


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


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


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


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


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

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


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


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