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

export function promiseMaybeDictionaryOfPotentiallyUnsafeNumberString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfPotentiallyUnsafeNumberString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfFiniteNumberString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfFiniteNumberString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfIntegerString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfIntegerString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfGreaterThanString (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfGreaterThanString(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfGreaterThanStringHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfGreaterThanString(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfGreaterThanOrEqualString (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfGreaterThanOrEqualString(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfGreaterThanOrEqualStringHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfGreaterThanOrEqualString(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfLessThanString (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLessThanString(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfLessThanStringHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfLessThanString(name, mixed, x);
    };
}


export function promiseMaybeDictionaryOfLessThanOrEqualString (name : string, mixed : any, x : number) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLessThanOrEqualString(name, mixed, x));
    });
}

export function promiseMaybeDictionaryOfLessThanOrEqualStringHandler (x : number) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfLessThanOrEqualString(name, mixed, x);
    };
}


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

export function promiseMaybeDictionaryOfRangeStringHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfRangeString(name, mixed, args);
    };
}


export function promiseMaybeDictionaryOfPositiveString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfPositiveString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNegativeString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNegativeString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNonNegativeString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNonNegativeString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfNaturalNumberString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfNaturalNumberString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfOddString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfOddString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfEvenString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfEvenString(name, mixed));
    });
}


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

export function promiseMaybeDictionaryOfNotOneOfStringHandler<T extends number> (arr : T[]) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfNotOneOfString(name, mixed, arr);
    };
}


export function promiseMaybeDictionaryOfLatitudeString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLatitudeString(name, mixed));
    });
}


export function promiseMaybeDictionaryOfLongitudeString (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> {
    return new Promise<null|undefined|({ [key : string] : string })>((resolve) => {
        resolve(assert.assertMaybeDictionaryOfLongitudeString(name, mixed));
    });
}