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

export function promiseArrayOfDictionaryOfString (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfString(name, mixed));
    });
}


export function promiseArrayOfDictionaryOfMinLength (name : string, mixed : any, min : number) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfMinLength(name, mixed, min));
    });
}

export function promiseArrayOfDictionaryOfMinLengthHandler (min : number) : (name : string, mixed : any) => Promise<({ [key : string] : string })[]> {
    return (name : string, mixed : any) : Promise<({ [key : string] : string })[]> => {
        return promiseArrayOfDictionaryOfMinLength(name, mixed, min);
    };
}


export function promiseArrayOfDictionaryOfMaxLength (name : string, mixed : any, max : number) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfMaxLength(name, mixed, max));
    });
}

export function promiseArrayOfDictionaryOfMaxLengthHandler (max : number) : (name : string, mixed : any) => Promise<({ [key : string] : string })[]> {
    return (name : string, mixed : any) : Promise<({ [key : string] : string })[]> => {
        return promiseArrayOfDictionaryOfMaxLength(name, mixed, max);
    };
}


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

export function promiseArrayOfDictionaryOfLengthHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<({ [key : string] : string })[]> {
    return (name : string, mixed : any) : Promise<({ [key : string] : string })[]> => {
        return promiseArrayOfDictionaryOfLength(name, mixed, args);
    };
}


export function promiseArrayOfDictionaryOfNonEmpty (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfNonEmpty(name, mixed));
    });
}


export function promiseArrayOfDictionaryOfContains (name : string, mixed : any, x : string) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfContains(name, mixed, x));
    });
}

export function promiseArrayOfDictionaryOfContainsHandler (x : string) : (name : string, mixed : any) => Promise<({ [key : string] : string })[]> {
    return (name : string, mixed : any) : Promise<({ [key : string] : string })[]> => {
        return promiseArrayOfDictionaryOfContains(name, mixed, x);
    };
}


export function promiseArrayOfDictionaryOfNoDuplicate (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfNoDuplicate(name, mixed));
    });
}


export function promiseArrayOfDictionaryOfNotAllWhitespace (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfNotAllWhitespace(name, mixed));
    });
}


export function promiseArrayOfDictionaryOfNonEmptyAndNotAllWhitespace (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfNonEmptyAndNotAllWhitespace(name, mixed));
    });
}


export function promiseArrayOfDictionaryOfMatch (name : string, mixed : any, regex : RegExp) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfMatch(name, mixed, regex));
    });
}

export function promiseArrayOfDictionaryOfMatchHandler (regex : RegExp) : (name : string, mixed : any) => Promise<({ [key : string] : string })[]> {
    return (name : string, mixed : any) : Promise<({ [key : string] : string })[]> => {
        return promiseArrayOfDictionaryOfMatch(name, mixed, regex);
    };
}


export function promiseArrayOfDictionaryOfEmail (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfEmail(name, mixed));
    });
}


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

export function promiseArrayOfDictionaryOfNotOneOfHandler<T extends string> (arr : T[]) : (name : string, mixed : any) => Promise<({ [key : string] : string })[]> {
    return (name : string, mixed : any) : Promise<({ [key : string] : string })[]> => {
        return promiseArrayOfDictionaryOfNotOneOf(name, mixed, arr);
    };
}


export function promiseArrayOfDictionaryOfBase64 (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfBase64(name, mixed));
    });
}


export function promiseArrayOfDictionaryOfJson (name : string, mixed : any) : Promise<({ [key : string] : string })[]> {
    return new Promise<({ [key : string] : string })[]>((resolve) => {
        resolve(assert.assertArrayOfDictionaryOfJson(name, mixed));
    });
}