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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

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


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


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

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


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


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