import * as GenericArrayCheck from "../../../../sync/check/generic/array";
import * as check from "../../../../sync/check/string";

export type ArrayOfStringResult = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode>;
export function checkArrayOfString (mixed : any) : undefined|ArrayOfStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkString
    );
}

export type ArrayOfMinLengthResult = GenericArrayCheck.IsArrayOfResult<check.MinLengthErrorCodeType>;
export function checkArrayOfMinLength (mixed : any, min : number) : undefined|ArrayOfMinLengthResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMinLength(mixed, min)
        }
    );
}

export type ArrayOfMaxLengthResult = GenericArrayCheck.IsArrayOfResult<check.MaxLengthErrorCodeType>;
export function checkArrayOfMaxLength (mixed : any, max : number) : undefined|ArrayOfMaxLengthResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaxLength(mixed, max)
        }
    );
}

export type ArrayOfLengthResult = GenericArrayCheck.IsArrayOfResult<check.LengthErrorCodeType>;
export function checkArrayOfLength (mixed : any, args : { min? : number, max? : number }) : undefined|ArrayOfLengthResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkLength(mixed, args)
        }
    );
}

export type ArrayOfNonEmptyResult = GenericArrayCheck.IsArrayOfResult<check.NonEmptyErrorCodeType>;
export function checkArrayOfNonEmpty (mixed : any) : undefined|ArrayOfNonEmptyResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNonEmpty
    );
}

export type ArrayOfContainsResult = GenericArrayCheck.IsArrayOfResult<check.ContainsErrorCodeType>;
export function checkArrayOfContains (mixed : any, x : string) : undefined|ArrayOfContainsResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkContains(mixed, x)
        }
    );
}

export type ArrayOfNoDuplicateResult = GenericArrayCheck.IsArrayOfResult<check.NoDuplicateErrorCodeType>;
export function checkArrayOfNoDuplicate (mixed : any) : undefined|ArrayOfNoDuplicateResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNoDuplicate
    );
}

export type ArrayOfNotAllWhitespaceResult = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode|check.NotAllWhitespaceErrorCode>;
export function checkArrayOfNotAllWhitespace (mixed : any) : undefined|ArrayOfNotAllWhitespaceResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNotAllWhitespace
    );
}

export type ArrayOfNonEmptyAndNotAllWhitespaceResult = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode|check.NonEmptyErrorCodeType|check.NotAllWhitespaceErrorCode>;
export function checkArrayOfNonEmptyAndNotAllWhitespace (mixed : any) : undefined|ArrayOfNonEmptyAndNotAllWhitespaceResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNonEmptyAndNotAllWhitespace
    );
}

export type ArrayOfMatchResult = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode|check.MatchErrorCode>;
export function checkArrayOfMatch (mixed : any, regex : RegExp) : undefined|ArrayOfMatchResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMatch(mixed, regex)
        }
    );
}

export type ArrayOfEmailResult = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode|check.EmailErrorCode>;
export function checkArrayOfEmail (mixed : any) : undefined|ArrayOfEmailResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkEmail
    );
}

export type ArrayOfNotOneOfResult = GenericArrayCheck.IsArrayOfResult<check.NotOneOfErrorTypeCode>;
export function checkArrayOfNotOneOf<T extends string> (mixed : any, arr : T[]) : undefined|ArrayOfNotOneOfResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkNotOneOf(mixed, arr)
        }
    );
}

export type ArrayOfBase64Result = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode|check.Base64ErrorCode>;
export function checkArrayOfBase64 (mixed : any) : undefined|ArrayOfBase64Result {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkBase64
    );
}

export type ArrayOfJsonResult = GenericArrayCheck.IsArrayOfResult<check.StringErrorCode|check.JsonErrorCode>;
export function checkArrayOfJson (mixed : any) : undefined|ArrayOfJsonResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkJson
    );
}