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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

export function promiseMaybeDictionaryOfMatchHandler (regex : RegExp) : (name : string, mixed : any) => Promise<null|undefined|({ [key : string] : string })> {
    return (name : string, mixed : any) : Promise<null|undefined|({ [key : string] : string })> => {
        return promiseMaybeDictionaryOfMatch(name, mixed, regex);
    };
}


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


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

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


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


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