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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

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


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


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

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


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


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