import * as GenericArrayCheck from "../../../../../sync/check/generic/array";
import * as check from "../../../../../generated/sync/check/string-format/number";

export type ArrayOfPotentiallyUnsafeNumberStringResult = GenericArrayCheck.IsArrayOfResult<check.PotentiallyUnsafeNumberStringResult>;
export function checkArrayOfPotentiallyUnsafeNumberString (mixed : any) : undefined|ArrayOfPotentiallyUnsafeNumberStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkPotentiallyUnsafeNumberString
    );
}

export type ArrayOfFiniteNumberStringResult = GenericArrayCheck.IsArrayOfResult<check.FiniteNumberStringResult>;
export function checkArrayOfFiniteNumberString (mixed : any) : undefined|ArrayOfFiniteNumberStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkFiniteNumberString
    );
}

export type ArrayOfIntegerStringResult = GenericArrayCheck.IsArrayOfResult<check.IntegerStringResult>;
export function checkArrayOfIntegerString (mixed : any) : undefined|ArrayOfIntegerStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkIntegerString
    );
}

export type ArrayOfGreaterThanStringResult = GenericArrayCheck.IsArrayOfResult<check.GreaterThanStringResult>;
export function checkArrayOfGreaterThanString (mixed : any, x : number) : undefined|ArrayOfGreaterThanStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkGreaterThanString(mixed, x)
        }
    );
}

export type ArrayOfGreaterThanOrEqualStringResult = GenericArrayCheck.IsArrayOfResult<check.GreaterThanOrEqualStringResult>;
export function checkArrayOfGreaterThanOrEqualString (mixed : any, x : number) : undefined|ArrayOfGreaterThanOrEqualStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkGreaterThanOrEqualString(mixed, x)
        }
    );
}

export type ArrayOfLessThanStringResult = GenericArrayCheck.IsArrayOfResult<check.LessThanStringResult>;
export function checkArrayOfLessThanString (mixed : any, x : number) : undefined|ArrayOfLessThanStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkLessThanString(mixed, x)
        }
    );
}

export type ArrayOfLessThanOrEqualStringResult = GenericArrayCheck.IsArrayOfResult<check.LessThanOrEqualStringResult>;
export function checkArrayOfLessThanOrEqualString (mixed : any, x : number) : undefined|ArrayOfLessThanOrEqualStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkLessThanOrEqualString(mixed, x)
        }
    );
}

export type ArrayOfRangeStringResult = GenericArrayCheck.IsArrayOfResult<check.RangeStringResult>;
export function checkArrayOfRangeString (mixed : any, args : { min? : number, max? : number }) : undefined|ArrayOfRangeStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkRangeString(mixed, args)
        }
    );
}

export type ArrayOfPositiveStringResult = GenericArrayCheck.IsArrayOfResult<check.PositiveStringResult>;
export function checkArrayOfPositiveString (mixed : any) : undefined|ArrayOfPositiveStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkPositiveString
    );
}

export type ArrayOfNegativeStringResult = GenericArrayCheck.IsArrayOfResult<check.NegativeStringResult>;
export function checkArrayOfNegativeString (mixed : any) : undefined|ArrayOfNegativeStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNegativeString
    );
}

export type ArrayOfNonNegativeStringResult = GenericArrayCheck.IsArrayOfResult<check.NonNegativeStringResult>;
export function checkArrayOfNonNegativeString (mixed : any) : undefined|ArrayOfNonNegativeStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNonNegativeString
    );
}

export type ArrayOfNaturalNumberStringResult = GenericArrayCheck.IsArrayOfResult<check.NaturalNumberStringResult>;
export function checkArrayOfNaturalNumberString (mixed : any) : undefined|ArrayOfNaturalNumberStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkNaturalNumberString
    );
}

export type ArrayOfOddStringResult = GenericArrayCheck.IsArrayOfResult<check.OddStringResult>;
export function checkArrayOfOddString (mixed : any) : undefined|ArrayOfOddStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkOddString
    );
}

export type ArrayOfEvenStringResult = GenericArrayCheck.IsArrayOfResult<check.EvenStringResult>;
export function checkArrayOfEvenString (mixed : any) : undefined|ArrayOfEvenStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkEvenString
    );
}

export type ArrayOfNotOneOfStringResult = GenericArrayCheck.IsArrayOfResult<check.NotOneOfStringResult>;
export function checkArrayOfNotOneOfString<T extends number> (mixed : any, arr : T[]) : undefined|ArrayOfNotOneOfStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        () => {
            return check.checkNotOneOfString(mixed, arr)
        }
    );
}

export type ArrayOfLatitudeStringResult = GenericArrayCheck.IsArrayOfResult<check.LatitudeStringResult>;
export function checkArrayOfLatitudeString (mixed : any) : undefined|ArrayOfLatitudeStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkLatitudeString
    );
}

export type ArrayOfLongitudeStringResult = GenericArrayCheck.IsArrayOfResult<check.LongitudeStringResult>;
export function checkArrayOfLongitudeString (mixed : any) : undefined|ArrayOfLongitudeStringResult {
    return GenericArrayCheck.checkArrayOf(
        mixed,
        check.checkLongitudeString
    );
}