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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

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


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


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

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


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


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