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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

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


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


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

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


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


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