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

export type ArrayOfMaybeStringResult = GenericArrayCheck.IsArrayOfResult<check.MaybeStringErrorCodeType>;
export function checkArrayOfMaybeString (mixed : any) : undefined|ArrayOfMaybeStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeString
    );
}

export type ArrayOfMaybeMinLengthResult = GenericArrayCheck.IsArrayOfResult<check.MaybeMinLengthErrorCodeType>;
export function checkArrayOfMaybeMinLength (mixed : any, min : number) : undefined|ArrayOfMaybeMinLengthResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaybeMinLength(mixed, min)
        }
    );
}

export type ArrayOfMaybeMaxLengthResult = GenericArrayCheck.IsArrayOfResult<check.MaybeMaxLengthErrorCodeType>;
export function checkArrayOfMaybeMaxLength (mixed : any, max : number) : undefined|ArrayOfMaybeMaxLengthResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaybeMaxLength(mixed, max)
        }
    );
}

export type ArrayOfMaybeLengthResult = GenericArrayCheck.IsArrayOfResult<check.MaybeLengthErrorCodeType>;
export function checkArrayOfMaybeLength (mixed : any, args : { min? : number, max? : number }) : undefined|ArrayOfMaybeLengthResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaybeLength(mixed, args)
        }
    );
}

export type ArrayOfMaybeNonEmptyResult = GenericArrayCheck.IsArrayOfResult<check.MaybeNonEmptyErrorCodeType>;
export function checkArrayOfMaybeNonEmpty (mixed : any) : undefined|ArrayOfMaybeNonEmptyResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeNonEmpty
    );
}

export type ArrayOfMaybeContainsResult = GenericArrayCheck.IsArrayOfResult<check.MaybeContainsErrorCodeType>;
export function checkArrayOfMaybeContains (mixed : any, x : string) : undefined|ArrayOfMaybeContainsResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaybeContains(mixed, x)
        }
    );
}

export type ArrayOfMaybeNoDuplicateResult = GenericArrayCheck.IsArrayOfResult<check.MaybeNoDuplicateErrorCodeType>;
export function checkArrayOfMaybeNoDuplicate (mixed : any) : undefined|ArrayOfMaybeNoDuplicateResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeNoDuplicate
    );
}

export type ArrayOfMaybeNotAllWhitespaceResult = GenericArrayCheck.IsArrayOfResult<check.MaybeNotAllWhitespaceErrorCodeType>;
export function checkArrayOfMaybeNotAllWhitespace (mixed : any) : undefined|ArrayOfMaybeNotAllWhitespaceResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeNotAllWhitespace
    );
}

export type ArrayOfMaybeNonEmptyAndNotAllWhitespaceResult = GenericArrayCheck.IsArrayOfResult<check.MaybeNonEmptyAndNotAllWhitespaceErrorCodeType>;
export function checkArrayOfMaybeNonEmptyAndNotAllWhitespace (mixed : any) : undefined|ArrayOfMaybeNonEmptyAndNotAllWhitespaceResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeNonEmptyAndNotAllWhitespace
    );
}

export type ArrayOfMaybeMatchResult = GenericArrayCheck.IsArrayOfResult<check.MaybeMatchErrorCodeType>;
export function checkArrayOfMaybeMatch (mixed : any, regex : RegExp) : undefined|ArrayOfMaybeMatchResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaybeMatch(mixed, regex)
        }
    );
}

export type ArrayOfMaybeEmailResult = GenericArrayCheck.IsArrayOfResult<check.MaybeEmailErrorCodeType>;
export function checkArrayOfMaybeEmail (mixed : any) : undefined|ArrayOfMaybeEmailResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeEmail
    );
}

export type ArrayOfMaybeNotOneOfResult = GenericArrayCheck.IsArrayOfResult<check.MaybeNotOneOfErrorCodeType>;
export function checkArrayOfMaybeNotOneOf<T extends string> (mixed : any, arr : T[]) : undefined|ArrayOfMaybeNotOneOfResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkMaybeNotOneOf(mixed, arr)
        }
    );
}

export type ArrayOfMaybeBase64Result = GenericArrayCheck.IsArrayOfResult<check.MaybeBase64ErrorCodeType>;
export function checkArrayOfMaybeBase64 (mixed : any) : undefined|ArrayOfMaybeBase64Result {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeBase64
    );
}

export type ArrayOfMaybeJsonResult = GenericArrayCheck.IsArrayOfResult<check.MaybeJsonErrorCodeType>;
export function checkArrayOfMaybeJson (mixed : any) : undefined|ArrayOfMaybeJsonResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkMaybeJson
    );
}