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

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


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

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


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

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


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

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


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


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

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


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


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


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


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

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


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


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

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


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


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