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

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


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


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


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

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


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

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


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

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


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

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


export function promiseMaybeDictionaryOfArrayOfRangeString (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.assertMaybeDictionaryOfArrayOfRangeString(name, mixed, args));
    });
}

export function promiseMaybeDictionaryOfArrayOfRangeStringHandler (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 promiseMaybeDictionaryOfArrayOfRangeString(name, mixed, args);
    };
}


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


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


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


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


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


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


export function promiseMaybeDictionaryOfArrayOfNotOneOfString<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.assertMaybeDictionaryOfArrayOfNotOneOfString(name, mixed, arr));
    });
}

export function promiseMaybeDictionaryOfArrayOfNotOneOfStringHandler<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 promiseMaybeDictionaryOfArrayOfNotOneOfString(name, mixed, arr);
    };
}


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


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