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

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


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

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


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

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


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

export function promiseMaybeArrayOfLengthHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<null|undefined|((string)[])> {
    return (name : string, mixed : any) : Promise<null|undefined|((string)[])> => {
        return promiseMaybeArrayOfLength(name, mixed, args);
    };
}


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


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

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


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


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


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


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

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


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


export function promiseMaybeArrayOfNotOneOf<T extends string> (name : string, mixed : any, arr : T[]) : Promise<null|undefined|((string)[])> {
    return new Promise<null|undefined|((string)[])>((resolve) => {
        resolve(assert.assertMaybeArrayOfNotOneOf(name, mixed, arr));
    });
}

export function promiseMaybeArrayOfNotOneOfHandler<T extends string> (arr : T[]) : (name : string, mixed : any) => Promise<null|undefined|((string)[])> {
    return (name : string, mixed : any) : Promise<null|undefined|((string)[])> => {
        return promiseMaybeArrayOfNotOneOf(name, mixed, arr);
    };
}


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


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