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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

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


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


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

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


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


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