diff --git a/src/main/java/com/sngular/annotation/pact/Example.java b/src/main/java/com/sngular/annotation/pact/Example.java
index b94e532..afc1436 100644
--- a/src/main/java/com/sngular/annotation/pact/Example.java
+++ b/src/main/java/com/sngular/annotation/pact/Example.java
@@ -18,4 +18,6 @@
   String value() default "";
 
   String format() default "";
+
+  String[] array() default { };
 }
diff --git a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java
index 77db721..26f0b28 100644
--- a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java
+++ b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java
@@ -1,9 +1,3 @@
-/*
- *  This Source Code Form is subject to the terms of the Mozilla Public
- *  * License, v. 2.0. If a copy of the MPL was not distributed with this
- *  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
 package com.sngular.annotation.processor;
 
 import java.io.IOException;
@@ -38,20 +32,7 @@
 import com.sngular.annotation.processor.exception.PactProcessorException;
 import com.sngular.annotation.processor.exception.TemplateFactoryException;
 import com.sngular.annotation.processor.exception.TemplateGenerationException;
-import com.sngular.annotation.processor.mapping.BigDecimalMapping;
-import com.sngular.annotation.processor.mapping.BigIntegerMapping;
-import com.sngular.annotation.processor.mapping.BooleanMapping;
-import com.sngular.annotation.processor.mapping.ByteMapping;
-import com.sngular.annotation.processor.mapping.CharMapping;
-import com.sngular.annotation.processor.mapping.DateMapping;
-import com.sngular.annotation.processor.mapping.DoubleMapping;
-import com.sngular.annotation.processor.mapping.FloatMapping;
-import com.sngular.annotation.processor.mapping.IntegerMapping;
-import com.sngular.annotation.processor.mapping.LongMapping;
-import com.sngular.annotation.processor.mapping.ShortMapping;
-import com.sngular.annotation.processor.mapping.StringMapping;
-import com.sngular.annotation.processor.mapping.TypeMapping;
-import com.sngular.annotation.processor.mapping.ZonedDateTimeMapping;
+import com.sngular.annotation.processor.mapping.*;
 import com.sngular.annotation.processor.model.ClassBuilderTemplate;
 import com.sngular.annotation.processor.model.DslComplexField;
 import com.sngular.annotation.processor.model.DslComplexTypeEnum;
@@ -101,6 +82,29 @@ public class PactDslProcessor extends AbstractProcessor {
                                                                    .put("ZonedDateTime", new ZonedDateTimeMapping())
                                                                    .put("java.util.Date", new DateMapping())
                                                                    .put("Date", new DateMapping())
+                                                                    .put("String[]", new StringArrayMapping())
+                                                                    .put("java.lang.String[]", new StringArrayMapping())
+                                                                    .put("boolean[]", new BooleanArrayMapping())
+                                                                    .put("java.lang.Boolean[]", new BooleanArrayWrapMapping())
+                                                                    .put("byte[]", new ByteArrayMapping())
+                                                                    .put("java.lang.Byte[]", new ByteArrayWrapMapping())
+                                                                    .put("short[]", new ShortArrayMapping())
+                                                                    .put("java.lang.Short[]", new ShortArrayWrapMapping())
+                                                                    .put("int[]", new IntArrayMapping())
+                                                                    .put("java.lang.Integer[]", new IntArrayWrapMapping())
+                                                                    .put("long[]", new LongArrayMapping())
+                                                                    .put("java.lang.Long[]", new LongArrayWrapMapping())
+                                                                    .put("char[]", new CharArrayMapping())
+                                                                    .put("java.lang.Character[]", new CharArrayWrapMapping())
+                                                                    .put("float[]", new FloatArrayMapping())
+                                                                    .put("java.lang.Float[]", new FloatArrayWrapMapping())
+                                                                    .put("double[]", new DoubleArrayMapping())
+                                                                    .put("java.lang.Double[]", new DoubleArrayWrapMapping())
+                                                                    .put("java.math.BigInteger[]", new BigIntegerArrayMapping())
+                                                                    .put("java.math.BigDecimal[]", new BigDecimalArrayMapping())
+                                                                    .put("java.time.ZonedDateTime[]", new ZonedDateTimeArrayMapping())
+                                                                    .put("java.util.Date[]", new DateArrayMapping())
+                                                                    .put("Date[]", new DateArrayMapping())
                                                                    .build();
 
   private static final String CUSTOM_MODIFIERS = "customModifiers";
@@ -128,6 +132,83 @@ private static String getFormat(final Element fieldElement, final String default
     return StringUtils.defaultIfEmpty(value, defaultFormat);
   }
 
+  /**
+   * This method gets the values obtained from the array attribute of the example annotation
+   * ( @Example(array = {"value1","value2"} )
+   * @param fieldElement Element, Class containing the attributes annotated with Example
+   * @param defaultFormat String, Array type.
+   * @return The processed strings to set the parameter: parametersimpleFieldBuilder.defaultValue
+   */
+  private static String getArrayFromExample(final Element fieldElement, final String defaultFormat) {
+    String[] value = fieldElement.getAnnotation(Example.class).array();
+    return PactDslProcessor.getStringFromArray(value,defaultFormat);
+  }
+
+  /**
+   * This method process the array of values to format them according to the type of array.
+   * @param arrayValues String[], Strings to be processed.
+   * @param arrayType String, Array type to be processed.
+   * @return The processed strings to set the parameter: parametersimpleFieldBuilder.defaultValue
+   */
+  private static String getStringFromArray(String[] arrayValues, String arrayType) {
+
+      int size = arrayValues.length-1;
+      String arrayToString = "";
+      String element = "";
+
+      for (int i = 0; i < arrayValues.length; i++) {
+
+        element = arrayValues[i];
+        switch (TypeArray.get(arrayType)) {
+          case STRING_ARRAY:
+            if (i == size) {
+              arrayToString += "\"" + element + "\"";
+            } else {
+              arrayToString += "\"" + element + "\",";
+            }
+            break;
+          case LONG_ARRAY:
+          case FLOAT_ARRAY:
+          case DOUBLE_ARRAY:
+          case BIG_INTEGER_ARRAY:
+          case BIG_DECIMAL_ARRAY:
+          case ZONED_DATE_TIME_ARRAY:
+          case DATE_ARRAY:
+            if (i == size) {                                  //ultimo elemento
+              if (i != 0) {
+                arrayToString += "\"" + element;              //si son mas de uno
+              } else { arrayToString += element; }            //si es unico elemento
+            } else {
+              if (i != 0) {
+                arrayToString += "\"" + element + "\",";      //si son mas de uno y elemento intermedio
+              } else { arrayToString += element + "\","; }    //si son mas de uno y primer elemento
+            }
+            break;
+          case BOOLEAN_ARRAY:
+          case BYTE_ARRAY:
+          case SHORT_ARRAY:
+          case INT_ARRAY:
+            if (i == size) {
+              arrayToString += element ;
+            } else {
+              arrayToString += element + ",";
+            }
+            break;
+
+          case CHAR_ARRAY:
+            if (i == size) {
+              arrayToString += "'" + element + "'";
+            } else {
+              arrayToString += "'" + element + "',";
+            }
+            break;
+          default:
+            arrayToString = "not_found_type_array";
+        }
+      }
+      return arrayToString;
+  }
+
   @Override
   public final SourceVersion getSupportedSourceVersion() {
     return SourceVersion.latestSupported();
@@ -345,13 +426,21 @@ private DslSimpleField.DslSimpleFieldBuilder createSimpleFieldBuilder(final Elem
                                                  .empty(false);
 
     if (Objects.nonNull(fieldElement.getAnnotation(DslExclude.class))) {
-      simpleFieldBuilder.empty(true);
+        simpleFieldBuilder.empty(true);
+
     } else if (Objects.nonNull(fieldElement.getAnnotation(Example.class))) {
-      simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType()));
-      simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue()));
+
+        if (fieldElement.getAnnotation(Example.class).array().length != 0) {
+            simpleFieldBuilder.defaultValue(getArrayFromExample(fieldElement, mapping.getFieldType()));
+            simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue()));
+
+        } else {
+            simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType()));
+            simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue()));
+        }
     } else {
-      simpleFieldBuilder.defaultValue(mapping.getRandomDefaultValue(validationBuilder.build(), randomSource));
-      simpleFieldBuilder.formatValue(mapping.getFormatValue());
+        simpleFieldBuilder.defaultValue(mapping.getRandomDefaultValue(validationBuilder.build(), randomSource));
+        simpleFieldBuilder.formatValue(mapping.getFormatValue());
     }
 
     return simpleFieldBuilder;
@@ -385,6 +474,7 @@ private static Object getDefaultValue(final Element fieldElement, final String t
   private Optional<TypeMapping<?>> extractMappingByType(final Element element) {
 
     final var type = element.asType();
+
     return switch (type.getKind()) {
       case BOOLEAN -> Optional.of(TYPE_MAPPING.get("boolean"));
       case BYTE -> Optional.of(TYPE_MAPPING.get("byte"));
@@ -394,10 +484,10 @@ private Optional<TypeMapping<?>> extractMappingByType(final Element element) {
       case CHAR -> Optional.of(TYPE_MAPPING.get("char"));
       case FLOAT -> Optional.of(TYPE_MAPPING.get("float"));
       case DOUBLE -> Optional.of(TYPE_MAPPING.get("double"));
+      case ARRAY -> Optional.of(TYPE_MAPPING.get(type.toString()));
       case DECLARED -> Optional.ofNullable(TYPE_MAPPING.get(this.typeUtils.asElement(type).getSimpleName().toString()));
       default -> Optional.empty();
     };
   }
-
 }
 
diff --git a/src/main/java/com/sngular/annotation/processor/TypeArray.java b/src/main/java/com/sngular/annotation/processor/TypeArray.java
new file mode 100644
index 0000000..d7bda95
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/TypeArray.java
@@ -0,0 +1,108 @@
+package com.sngular.annotation.processor;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/** Represents an enum of array types.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public enum TypeArray {
+
+    /**
+     * An array type {@code String[]}.
+     */
+    STRING_ARRAY("","String[]"),
+    /**
+     * An array type {@code boolean[]}.
+     */
+    BOOLEAN_ARRAY("boolean[]","Boolean[]"),
+
+    /**
+     * An array type {@code byte[]}.
+     */
+    BYTE_ARRAY("byte[]","Byte[]"),
+
+    /**
+     * An array type {@code short[]}.
+     */
+    SHORT_ARRAY("short[]","Short[]"),
+
+    /**
+     * An array type {@code int[]}.
+     */
+    INT_ARRAY("int[]","Integer[]"),
+
+    /**
+     * An array type {@code long[]}.
+     */
+    LONG_ARRAY("long[]","Long[]"),
+
+    /**
+     * An array type {@code char[]}.
+     */
+    CHAR_ARRAY("char[]","Character[]"),
+
+    /**
+     * An array type {@code float[]}.
+     */
+    FLOAT_ARRAY("float[]","Float[]"),
+
+    /**
+     * An array type {@code double[]}.
+     */
+    DOUBLE_ARRAY("double[]","Double[]"),
+
+    /**
+     * An array type {@code BigInteger[]}.
+     */
+    BIG_INTEGER_ARRAY("","BigInteger[]"),
+
+    /**
+     * An array type {@code BigDecimal[]}.
+     */
+    BIG_DECIMAL_ARRAY("","BigDecimal[]"),
+
+    /**
+     * An array type {@code ZonedDateTime[]}.
+     */
+    ZONED_DATE_TIME_ARRAY("","ZonedDateTime[]"),
+
+    /**
+     * An array type {@code Date[]}.
+     */
+    DATE_ARRAY("","Date[]");
+
+    private String primitiveName;
+    private String objectName;
+
+    TypeArray(String primitiveName, String objectName) {
+        this.primitiveName = primitiveName;
+        this.objectName = objectName;
+    }
+    /**
+     * {@return primitive name}
+     */
+    public String getPrimitiveName() {
+        return primitiveName;
+    }
+
+    /**
+     * {@return object name}
+     */
+    public String getobjectName() {
+        return objectName;
+    }
+
+    /**
+     * {@return TypeArray value that matches typeString}
+     */
+    public static TypeArray get(String typeString) {
+        Optional<TypeArray> op = Arrays.stream(TypeArray.values())
+                .filter(typeArray -> typeArray.primitiveName.equals(typeString)
+                        || typeArray.objectName.equals(typeString))
+                .findFirst();
+
+        return op.get();
+    }
+}
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java
new file mode 100644
index 0000000..6818421
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java
@@ -0,0 +1,27 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+public class BigDecimalArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "BigDecimal[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "bigDecimalArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "bigDecimalArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "12345678901234567890123456789012345678901234567890123456789012345678901234567890.901234567890123456789012345678901234567890";
+  }
+}
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java
new file mode 100644
index 0000000..14a796d
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java
@@ -0,0 +1,33 @@
+/*
+ *  This Source Code Form is subject to the terms of the Mozilla Public
+ *  * License, v. 2.0. If a copy of the MPL was not distributed with this
+ *  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+public class BigIntegerArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "BigInteger[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "bigIntegerArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "bigIntegerArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "12345678901234567890123456789012345678901234567890123456789012345678901234567890";
+  }
+}
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java
new file mode 100644
index 0000000..ee7f5a1
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of boolean.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class BooleanArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "boolean[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "booleanArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "booleanArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "true";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java
new file mode 100644
index 0000000..2d8dc52
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of Boolean.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class BooleanArrayWrapMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Boolean[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "booleanArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "booleanArrayWrapValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "false";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java
new file mode 100644
index 0000000..d090efe
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of byte.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class ByteArrayMapping implements TypeMapping<Integer> {
+
+  @Override
+  public final String getFieldType() {
+    return "byte[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "byteArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "byteArrayValue";
+  }
+
+  @Override
+  public final Integer getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return -128;
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java
new file mode 100644
index 0000000..acca723
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of Byte.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class ByteArrayWrapMapping implements TypeMapping<Integer> {
+
+  @Override
+  public final String getFieldType() {
+    return "Byte[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "byteArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "byteArrayWrapValue";
+  }
+
+  @Override
+  public final Integer getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return 127;
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java
new file mode 100644
index 0000000..991b8d3
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java
@@ -0,0 +1,30 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of char.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class CharArrayMapping implements TypeMapping<String> {
+  @Override
+  public final String getFieldType() {
+    return "char[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "charArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "charArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "'x'";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java
new file mode 100644
index 0000000..b0d91eb
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+
+/** Represents an array of Character.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class CharArrayWrapMapping implements TypeMapping<String> {
+  @Override
+  public final String getFieldType() {
+    return "Character[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "charArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "charArrayWrapValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "'X'";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java
new file mode 100644
index 0000000..4dc7e16
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java
@@ -0,0 +1,32 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+public class DateArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Date[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "dateArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "dateArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "Wed Feb 28 13:59:00 CST 2024";
+  }
+
+  @Override
+  public final String getFormatValue() {
+    return "yyyy-MM-dd";
+  }
+}
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java
new file mode 100644
index 0000000..52d4cdc
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java
@@ -0,0 +1,36 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of double.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class DoubleArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "double[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "floatArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "floatArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "-1234567890123456789012345678901234567890.79769313486232d";
+  }
+
+  @Override
+  public final String getSuffixValue() {
+    return "D";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java
new file mode 100644
index 0000000..fa715e8
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java
@@ -0,0 +1,36 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of Double.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class DoubleArrayWrapMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Double[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "doubleArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "doubleArrayWrapValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "1234567890123456789012345678901234567890.79769313486232D";
+  }
+
+  @Override
+  public final String getSuffixValue() {
+    return "D";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java
new file mode 100644
index 0000000..05b90bf
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java
@@ -0,0 +1,36 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of float.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class FloatArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "float[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "floatArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "floatArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "-123456789012345678901234567890.402823f";
+  }
+
+  @Override
+  public final String getSuffixValue() {
+    return "F";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java
new file mode 100644
index 0000000..b15d1bb
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java
@@ -0,0 +1,36 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of Float.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class FloatArrayWrapMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Float[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "floatArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "floatArrayWrapValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "123456789012345678901234567890.402823F";
+  }
+
+  @Override
+  public final String getSuffixValue() {
+    return "F";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java
new file mode 100644
index 0000000..908d21f
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of int.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class IntArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "int[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "intArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "intArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "-2147483648";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java
new file mode 100644
index 0000000..90310fa
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of int.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class IntArrayWrapMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Integer[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "intArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "intArrayWrapValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "2147483647";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java
new file mode 100644
index 0000000..87aebc5
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java
@@ -0,0 +1,36 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of long.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class LongArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "long[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "longArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "longArrayType";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "-9223372036854775808l";
+  }
+
+  @Override
+  public final String getSuffixValue() {
+    return "L";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java
new file mode 100644
index 0000000..12c6901
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java
@@ -0,0 +1,36 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of Long.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class LongArrayWrapMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Long[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "longArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "longArrayWrapType";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "9223372036854775807L";
+  }
+
+  @Override
+  public final String getSuffixValue() {
+    return "L";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java
new file mode 100644
index 0000000..06a466d
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of short.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class ShortArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "short[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "shortArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "shortArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return 	"-32768";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java
new file mode 100644
index 0000000..70d6685
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java
@@ -0,0 +1,31 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+/** Represents an array of Short.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class ShortArrayWrapMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "Short[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "shortArrayWrapType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "shortArrayWrapValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "32767";
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java
new file mode 100644
index 0000000..2d92aad
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java
@@ -0,0 +1,46 @@
+/*
+ *  This Source Code Form is subject to the terms of the Mozilla Public
+ *  * License, v. 2.0. If a copy of the MPL was not distributed with this
+ *  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.apache.commons.rng.UniformRandomProvider;
+
+import java.util.Objects;
+
+
+/** Represents an array of String.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class StringArrayMapping implements TypeMapping<String> {
+
+  public static final int DEFAULT_MAX = 15;
+
+  public static final int DEFAULT_MIN = 1;
+
+  @Override
+  public final String getFieldType() {
+    return "String[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "stringArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "stringArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "\"defaultValue\"";
+  }
+}
diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java
new file mode 100644
index 0000000..2db44cb
--- /dev/null
+++ b/src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java
@@ -0,0 +1,32 @@
+package com.sngular.annotation.processor.mapping;
+
+import com.sngular.annotation.processor.model.FieldValidations;
+import org.apache.commons.rng.UniformRandomProvider;
+
+public class ZonedDateTimeArrayMapping implements TypeMapping<String> {
+
+  @Override
+  public final String getFieldType() {
+    return "ZonedDateTime[]";
+  }
+
+  @Override
+  public final String getFunctionType() {
+    return "zonedDateTimeArrayType";
+  }
+
+  @Override
+  public final String getFunctionOnlyValue() {
+    return "zonedDateTimeArrayValue";
+  }
+
+  @Override
+  public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) {
+    return "2024-02-28T13:59-06:00[America/Mexico_City]";
+  }
+
+  @Override
+  public final String getFormatValue() {
+    return "yyyy-MM-dd'T'HH:mm:ss[.SSSSSS][.SSS]XXX['['VV']']";
+  }
+}
diff --git a/src/main/resources/templates/templateDslBuilder.ftlh b/src/main/resources/templates/templateDslBuilder.ftlh
index e29a080..59d236f 100644
--- a/src/main/resources/templates/templateDslBuilder.ftlh
+++ b/src/main/resources/templates/templateDslBuilder.ftlh
@@ -1,7 +1,68 @@
 <#assign constructor = false>
 <#macro writeAttrField field>
   <#if field.functionByType??>
-    <#if field.fieldType == "boolean">
+    <#if field.fieldType == "String[]"
+        || field.fieldType == "char[]" || field.fieldType == "Character[]"
+        || field.fieldType == "boolean[]" || field.fieldType == "Boolean[]"
+        || field.fieldType == "byte[]" || field.fieldType == "Byte[]"
+        || field.fieldType == "short[]" || field.fieldType == "Short[]"
+        || field.fieldType == "int[]" || field.fieldType == "Integer[]">
+      ${field.fieldType} ${field.name} = {${field.defaultValue?no_esc}};
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "long[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getLongArray(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "Long[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getLongArrayWrap(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "float[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getFloatArray(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "Float[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getFloatArrayWrap(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "double[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getDoubleArray(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "Double[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getDoubleArrayWrap(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "BigInteger[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getBigIntegerArray(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "BigDecimal[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      ${field.fieldType} ${field.name} = getBigDecimalArray(in${field.name?cap_first});
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "ZonedDateTime[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      String ${field.name}Format = "${field.formatValue?no_esc}";
+      ${field.fieldType} ${field.name} = getZonedDateTimeArray(in${field.name?cap_first},${field.name}Format);
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "Date[]">
+      String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"};
+      String ${field.name}Format = "${field.formatValue?no_esc}";
+      ${field.fieldType} ${field.name} = getDateArray(in${field.name?cap_first},${field.name}Format);
+      String ${field.name}Name = "${field.name}";
+
+    <#elseif field.fieldType == "boolean">
       ${field.fieldType} ${field.name} = ${field.defaultValue?string};
     <#elseif field.fieldType == "char">
       String ${field.name} = "${field.defaultValue}";
@@ -44,11 +105,11 @@
 
 <#macro writeSetterField field builderName>
 <#if field.functionByType??>
-  <#if field.fieldType == "char">
-      public ${builderName}Builder set${field.name?cap_first}(final String ${field.name}) {
-  <#else>
-    public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) {
-  </#if>
+    <#if field.fieldType == "char">
+          public ${builderName}Builder set${field.name?cap_first}(final String ${field.name}) {
+    <#else >
+          public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) {
+    </#if>
 <#elseif field.complexType??>
 <#if field.complexType.name() == "COLLECTION">
   public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) {
@@ -67,11 +128,11 @@
 
 <#macro writeExpectedInstanceSetters field>
   <#if !field.empty>
-    <#if field.fieldType == "char">
+        <#if field.fieldType == "char">
           object.set${field.name?cap_first}(this.${field.name}.charAt(0));
-    <#else>
+        <#else >
           object.set${field.name?cap_first}(this.${field.name});
-    </#if>
+        </#if>
   </#if>
 </#macro>
 
@@ -99,11 +160,13 @@
       <#if field.name?has_content>
           if (Objects.nonNull(${field.name})) {
           <#if field.formatValue??>
-           <#if field.functionByType != "datetime">
-            pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name});
-           <#else>
-            pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name}.toInstant());
-           </#if>
+            <#if field.fieldType == "ZonedDateTime[]" || field.fieldType == "Date[]">
+              pactDslJsonBody.array(${field.name}Name).stringValue(Arrays.toString(${field.name})).closeArray();
+            <#elseif field.functionByType != "datetime">
+              pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name});
+            <#else>
+              pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name}.toInstant());
+             </#if>
           <#elseif field.fieldType == "short">
             pactDslJsonBody.${field.functionByType}("${field.name}", (int) ${field.name});
           <#elseif field.fieldType == "BigInteger">
@@ -112,6 +175,18 @@
             pactDslJsonBody.${field.functionByType}("${field.name}", (double) ${field.name});
           <#elseif field.fieldType == "byte">
             pactDslJsonBody.${field.functionByType}("${field.name}", (int) ${field.name});
+          <#elseif field.fieldType == "String[]"
+                || field.fieldType == "char[]" || field.fieldType == "Character[]"
+                || field.fieldType == "boolean[]" || field.fieldType == "Boolean[]"
+                || field.fieldType == "byte[]" || field.fieldType == "Byte[]"
+                || field.fieldType == "short[]" || field.fieldType == "Short[]"
+                || field.fieldType == "int[]" || field.fieldType == "Integer[]"
+                || field.fieldType == "long[]" || field.fieldType == "Long[]"
+                || field.fieldType == "float[]" || field.fieldType == "Float[]"
+                || field.fieldType == "double[]" || field.fieldType == "Double[]"
+                || field.fieldType == "BigInteger[]" || field.fieldType == "BigDecimal[]">
+
+            pactDslJsonBody.array(${field.name}Name).stringValue(Arrays.toString(${field.name})).closeArray();
           <#else>
             pactDslJsonBody.${field.functionByType}("${field.name}", ${field.name});
           </#if>
@@ -247,6 +322,9 @@ import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.time.Instant;
 import java.time.LocalDate;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Date;
@@ -260,10 +338,8 @@ import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
 <#if schema.customModifiers??>
 import com.sngular.annotation.processor.mapping.CustomDslModifier;
 </#if>
-
-
 import ${schema.modelPackage}.${schema.className};
-
+import java.util.Arrays;
 <#function complex(field)>
   <#return field.functionByType??>
 </#function>
@@ -329,5 +405,121 @@ public class ${schema.className}Builder {
     }
     </#if>
 
-}
+    public static long[] getLongArray(String[] numbers) {
+      long[] result = new long[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = Long.parseLong(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("long value expected but was: "+numbers[i]);
+          result[i] = 0l;
+        }
+      return result;
+    }
 
+    public static Long[] getLongArrayWrap(String[] numbers) {
+      Long[] result = new Long[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = Long.parseLong(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("Long value expected but was: "+numbers[i]);
+          result[i] = 0L;
+        }
+      return result;
+    }
+
+    public static float[] getFloatArray(String[] numbers) {
+      float[] result = new float[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = Float.parseFloat(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("float value expected but was: "+numbers[i]);
+          result[i] = 0.0f;
+        }
+      return result;
+    }
+
+    public static Float[] getFloatArrayWrap(String[] numbers) {
+      Float[] result = new Float[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = Float.parseFloat(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("Float value expected but was: "+numbers[i]);
+          result[i] = 0.0F;
+        }
+      return result;
+    }
+
+    public static double[] getDoubleArray(String[] numbers) {
+      double[] result = new double[numbers.length];
+       for (int i = 0; i < numbers.length; i++)
+         try { result[i] = Double.parseDouble(numbers[i]);
+         } catch (NumberFormatException nfe) {
+           System.out.println("double value expected but was: "+numbers[i]);
+           result[i] = 0.0d;
+         }
+       return result;
+    }
+
+    public static Double[] getDoubleArrayWrap(String[] numbers) {
+      Double[] result = new Double[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = Double.parseDouble(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("Double value expected but was: "+numbers[i]);
+          result[i] = 0.0D;
+        }
+      return result;
+    }
+
+    public static BigInteger[] getBigIntegerArray(String[] numbers) {
+      BigInteger[] result = new BigInteger[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = new BigInteger(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("BigInteger value expected but was: "+numbers[i]);
+          result[i] = new BigInteger("0");
+        }
+      return result;
+    }
+
+    public static BigDecimal[] getBigDecimalArray(String[] numbers) {
+      BigDecimal[] result = new BigDecimal[numbers.length];
+      for (int i = 0; i < numbers.length; i++)
+        try { result[i] = new BigDecimal(numbers[i]);
+        } catch (NumberFormatException nfe) {
+          System.out.println("BigDecimal value expected but was: "+numbers[i]);
+          result[i] = new BigDecimal("0.0");
+        }
+      return result;
+    }
+
+    public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) {
+        ZonedDateTime[] result = new ZonedDateTime[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+          try {
+            result[i] = LocalDateTime
+                    .parse(numbers[i],DateTimeFormatter.ofPattern(format))
+                    .atZone(ZoneId.systemDefault())
+                    .withZoneSameInstant(ZoneId.systemDefault());
+
+          } catch (DateTimeException dte) {
+            System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+            System.out.println("    "+dte.getMessage());
+            result[i] = ZonedDateTime.now();
+          }
+        return result;
+      }
+
+      public static Date[] getDateArray(String[] numbers, String format) {
+        Date[] result = new Date[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+          try {
+            result[i] = new SimpleDateFormat(format).parse(numbers[i]);
+          } catch (Exception dte) {
+            System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+            System.out.println("    "+dte.getMessage());
+            result[i] = new Date();
+          }
+        return result;
+      }
+ }
\ No newline at end of file
diff --git a/src/test/java/com/sngular/annotation/processor/ArrayTest.java b/src/test/java/com/sngular/annotation/processor/ArrayTest.java
new file mode 100644
index 0000000..a55b5c4
--- /dev/null
+++ b/src/test/java/com/sngular/annotation/processor/ArrayTest.java
@@ -0,0 +1,24 @@
+package com.sngular.annotation.processor;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import org.junit.jupiter.api.Test;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+
+/** Represents a test of array types.
+ * @author Miguel Angel Escobar
+ * @version 1.0
+ */
+public class ArrayTest {
+
+  @Test
+  public void arrays() {
+
+    Compilation compilation = javac().withProcessors(new PactDslProcessor()).compile(JavaFileObjects.forResource("basic/ArrayDataTypes.java"));
+    assertThat(compilation).succeeded();
+    assertThat(compilation).generatedSourceFile("com/sngular/resources/basic/ArrayDataTypesBuilder")
+                           .hasSourceEquivalentTo(JavaFileObjects.forResource("basic/ArrayDataTypesBuilder.java"));
+  }
+}
diff --git a/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java b/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java
index 8ee0e0c..de1577e 100644
--- a/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java
+++ b/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java
@@ -14,10 +14,10 @@ public class RandomValueGenerationTest {
   public void numericDataTypes() {
     var theMock = Mockito.mock(RestorableUniformRandomProvider.class);
     Mockito.when(theMock.nextInt(0, Integer.MAX_VALUE)).thenReturn(18);
-    Compilation compilation = Compiler.javac().withProcessors( new PactDslProcessor(theMock)).compile(JavaFileObjects.forResource("random/NumericDataTypes.java"));
+    Compilation compilation = Compiler.javac().withProcessors( new PactDslProcessor(theMock)).compile(JavaFileObjects.forResource("random/RandomValueGeneration.java"));
     CompilationSubject.assertThat(compilation).succeeded();
-    CompilationSubject.assertThat(compilation).generatedSourceFile("com/sngular/annotation/examples/NumericDataTypesBuilder")
-                      .hasSourceEquivalentTo(JavaFileObjects.forResource("random/NumericDataTypesBuilder.java"));
+    CompilationSubject.assertThat(compilation).generatedSourceFile("com/sngular/annotation/examples/RandomValueGenerationBuilder")
+                      .hasSourceEquivalentTo(JavaFileObjects.forResource("random/RandomValueGenerationBuilder.java"));
 
   }
 }
diff --git a/src/test/resources/basic/ArrayDataTypes.java b/src/test/resources/basic/ArrayDataTypes.java
new file mode 100644
index 0000000..0bca76d
--- /dev/null
+++ b/src/test/resources/basic/ArrayDataTypes.java
@@ -0,0 +1,338 @@
+package com.sngular.resources.basic;
+
+import com.sngular.annotation.pact.Example;
+import com.sngular.annotation.pact.PactDslBodyBuilder;
+import com.sngular.annotation.pact.DslExclude;
+
+import java.math.BigInteger;
+import java.math.BigDecimal;
+import java.time.ZonedDateTime;
+import java.util.Optional;
+import java.util.Date;
+
+@PactDslBodyBuilder
+public class ArrayDataTypes {
+
+  @Example(array = {"abc","bef","ghi"} )
+  private String[] stringArray;
+
+  @DslExclude
+  private String[] stringArrayExclude;
+
+  @Example(array = {"true","false"})
+  private boolean[] booleanArray;
+
+  @Example(array = {"false","true"})
+  private Boolean[] booleanArrayWrap;
+
+  @Example(array = {"1","2","3","4","5"})
+  private byte[] byteArray;
+
+  @Example(array = {"6","7","8","9","10"})
+  private Byte[] byteArrayWrap;
+
+  @Example(array = {"11","12","13","14","15"} )
+  private short[] shortArray;
+
+  @Example(array = {"16","17","18","19","20"} )
+  private Short[] shortArrayWrap;
+
+  @Example(array = {"-2147483648"} )
+  private int[] intArray;
+
+  @Example(array = {"2147483647"} )
+  private Integer[] intArrayWrap;
+
+  @Example(array = {"j","k","l"} )
+  private char[] charArray;
+
+  @Example(array = {"m","n","o"} )
+  private Character[] charArrayWrap;
+
+  @Example(array = {"-9223372036854775807l",
+          "9223372036854775807L",
+          "-0l",
+          "0L",
+          "-3.402823e38",
+          "0.0",
+          "al"} )
+  private long[] longArray;
+
+  @Example(array = {"-9223372036854775807l",
+                    "9223372036854775807L",
+                    "-0l",
+                    "0L",
+                    "-3.402823e38",
+                    "-0.0",
+                    "aL"} )
+  private Long[] longArrayWrap;
+
+  @Example(array = {"-82233720368547758080000001f",
+                    "100.0F",
+                    "-123456789012345678901234567890123456789f",
+                    "123456789012345678901234567890123456789F",
+                    "-3.402823e38",
+                    "0.0",
+                    "af"} )
+  private float[] floatArray;
+
+  @Example(array = {"-1234567890123456789012345678901234567890.79769313486232d",
+                    "1000.0D",
+                    "-123456789012345678901234567890123456789d",
+                    "123456789012345678901234567890123456789D",
+                    "-3.402823e300d",
+                    "-0.0",
+                    "aF"} )
+  private Float[] floatArrayWrap;
+
+  @Example(array = {"-1234567890123456789012345678901234567890.79769313486232d",
+                  "1000.0D",
+                  "1234567890123456789012345678901234567890123456789012345678901234567890D",
+                  "-2.12345678901234d",
+                  "3.402823e307D",
+                  "0.0",
+                  "ad"} )
+  private double[] doubleArray;
+
+  @Example(array = {"-1234567890123456789012345678901234567890.79769313486232d",
+                  "1000.0D",
+                  "1234567890123456789012345678901234567890123456789012345678901234567890D",
+                  "-2.12345678901234d",
+                  "3.402823e307D",
+                  "-0.0",
+                  "aD"} )
+  private Double[] doubleArrayWrap;
+
+  @Example(array = {"-8223372036854775808000000182233720368547758000182233720368547758080000001",
+          "9542233720368547758080000001822334563456435643720367867865758000182233720352345368547758080000001",
+          "100.0",
+          "0",
+          "-0",
+          "abc"})
+  private BigInteger[] bigIntegerArray;
+
+  @Example(array = {"-8223372036854775808000000182233720368547758000182233720368547758080000001.8000182233720368547758080000001",
+          "954223372036854775808000000135643720367867865758000182233720352345368547758080000001.58000182233720352345368547758080000001",
+          "100.0",
+          "0",
+          "-0",
+          "abc"})
+  private BigDecimal[] bigDecimalArray;
+
+  @Example(array = {"28/02/2024 00:00",
+                    "28/02/2024 23:59",
+                    "30/02/2024 00:00",
+                    "28/03/2024 25:00",
+                    "28/04/2024 23:70",
+                    "00/00/0000 00:00",
+                    "12345",
+                    "100.100",
+                    "abc"}, format = "dd/MM/yyyy HH:mm")
+  private ZonedDateTime[] zonedDateTimeArray;
+
+  @Example(array = {"2024-02-28 00:00",
+                    "2024-02-28 23:59",
+                    "2024-02-30 00:00",
+                    "2024-03-28 25:00",
+                    "2024-04-28 23:70",
+                    "0000-00-00 00:00",
+                    "12345",
+                    "100.100",
+                    "abc"}, format = "yyyy-MM-dd HH:mm")
+  private ZonedDateTime[] zonedDateTimeArray2;
+
+  @Example(array = {"28/02/2024",
+                    "28/02/2024",
+                    "30/02/2024",
+                    "28/03/2024",
+                    "28/04/2024",
+                    "00/00/0000",
+                    "12345",
+                    "100.100",
+                    "abc"}, format = "dd/MM/yyyy")
+  private Date[] dateArray;
+
+  public String[] getStringArray() {
+    return stringArray;
+  }
+
+  public void setStringArray(String[] stringArray) {
+    this.stringArray = stringArray;
+  }
+
+  public String[] getStringArrayExclude() {
+    return stringArrayExclude;
+  }
+
+  public void setStringArrayExclude(String[] stringArrayExclude) {
+    this.stringArrayExclude = stringArrayExclude;
+  }
+
+  public boolean[] getBooleanArray() {
+    return booleanArray;
+  }
+
+  public void setBooleanArray(boolean[] booleanArray) {
+    this.booleanArray = booleanArray;
+  }
+
+  public Boolean[] getBooleanArrayWrap() {
+    return booleanArrayWrap;
+  }
+
+  public void setBooleanArrayWrap(Boolean[] booleanArrayWrap) {
+    this.booleanArrayWrap = booleanArrayWrap;
+  }
+
+  public byte[] getByteArray() {
+    return byteArray;
+  }
+
+  public void setByteArray(byte[] byteArray) {
+    this.byteArray = byteArray;
+  }
+
+  public Byte[] getByteArrayWrap() {
+    return byteArrayWrap;
+  }
+
+  public void setByteArrayWrap(Byte[] byteArrayWrap) {
+    this.byteArrayWrap = byteArrayWrap;
+  }
+
+  public short[] getShortArray() {
+    return shortArray;
+  }
+
+  public void setShortArray(short[] shortArray) {
+    this.shortArray = shortArray;
+  }
+
+  public Short[] getShortArrayWrap() {
+    return shortArrayWrap;
+  }
+
+  public void setShortArrayWrap(Short[] shortArrayWrap) {
+    this.shortArrayWrap = shortArrayWrap;
+  }
+
+  public int[] getIntArray() {
+    return intArray;
+  }
+
+  public void setIntArray(int[] intArray) {
+    this.intArray = intArray;
+  }
+
+  public Integer[] getIntArrayWrap() {
+    return intArrayWrap;
+  }
+
+  public void setIntArrayWrap(Integer[] intArrayWrap) {
+    this.intArrayWrap = intArrayWrap;
+  }
+
+  public char[] getCharArray() {
+    return charArray;
+  }
+
+  public void setCharArray(char[] charArray) {
+    this.charArray = charArray;
+  }
+
+  public Character[] getCharArrayWrap() {
+    return charArrayWrap;
+  }
+
+  public void setCharArrayWrap(Character[] charArrayWrap) {
+    this.charArrayWrap = charArrayWrap;
+  }
+
+  public long[] getLongArray() {
+    return longArray;
+  }
+
+  public void setLongArray(long[] longArray) {
+    this.longArray = longArray;
+  }
+
+  public Long[] getLongArrayWrap() {
+    return longArrayWrap;
+  }
+
+  public void setLongArrayWrap(Long[] longArrayWrap) {
+    this.longArrayWrap = longArrayWrap;
+  }
+
+  public float[] getFloatArray() {
+    return floatArray;
+  }
+
+  public void setFloatArray(float[] floatArray) {
+    this.floatArray = floatArray;
+  }
+
+  public Float[] getFloatArrayWrap() {
+    return floatArrayWrap;
+  }
+
+  public void setFloatArrayWrap(Float[] floatArrayWrap) {
+    this.floatArrayWrap = floatArrayWrap;
+  }
+
+  public double[] getDoubleArray() {
+    return doubleArray;
+  }
+
+  public void setDoubleArray(double[] doubleArray) {
+    this.doubleArray = doubleArray;
+  }
+
+  public Double[] getDoubleArrayWrap() {
+    return doubleArrayWrap;
+  }
+
+  public void setDoubleArrayWrap(Double[] doubleArrayWrap) {
+    this.doubleArrayWrap = doubleArrayWrap;
+  }
+
+  public BigInteger[] getBigIntegerArray() {
+    return bigIntegerArray;
+  }
+
+  public void setBigIntegerArray(BigInteger[] bigIntegerArray) {
+    this.bigIntegerArray = bigIntegerArray;
+  }
+
+  public BigDecimal[] getBigDecimalArray() {
+    return bigDecimalArray;
+  }
+
+  public void setBigDecimalArray(BigDecimal[] bigDecimalArray) {
+    this.bigDecimalArray = bigDecimalArray;
+  }
+
+  public ZonedDateTime[] getZonedDateTimeArray() {
+    return zonedDateTimeArray;
+  }
+
+  public void setZonedDateTimeArray(ZonedDateTime[] zonedDateTimeArray) {
+    this.zonedDateTimeArray = zonedDateTimeArray;
+  }
+
+  public ZonedDateTime[] getZonedDateTimeArray2() {
+    return zonedDateTimeArray2;
+  }
+
+  public void setZonedDateTimeArray2(ZonedDateTime[] zonedDateTimeArray2) {
+    this.zonedDateTimeArray2 = zonedDateTimeArray2;
+  }
+
+  public Date[] getDateArray() {
+    return dateArray;
+  }
+
+  public void setDateArray(Date[] dateArray) {
+    dateArray = dateArray;
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/basic/ArrayDataTypesBuilder.java b/src/test/resources/basic/ArrayDataTypesBuilder.java
new file mode 100644
index 0000000..714502a
--- /dev/null
+++ b/src/test/resources/basic/ArrayDataTypesBuilder.java
@@ -0,0 +1,536 @@
+package com.sngular.resources.basic;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+import au.com.dius.pact.consumer.dsl.DslPart;
+import au.com.dius.pact.consumer.dsl.PactDslJsonArray;
+import au.com.dius.pact.consumer.dsl.PactDslJsonBody;
+import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
+import com.sngular.annotation.processor.mapping.CustomDslModifier;
+import com.sngular.resources.basic.ArrayDataTypes;
+import java.util.Arrays;
+
+public class ArrayDataTypesBuilder {
+
+    String[] stringArray = {"abc","bef","ghi"};
+    String stringArrayName = "stringArray";
+
+    boolean[] booleanArray = {true, false};
+    String booleanArrayName = "booleanArray";
+
+    Boolean[] booleanArrayWrap = {false, true};
+    String booleanArrayWrapName = "booleanArrayWrap";
+
+    byte[] byteArray = {1,2,3,4,5};
+    String byteArrayName = "byteArray";
+
+    Byte[] byteArrayWrap = {6,7,8,9,10};
+    String byteArrayWrapName = "byteArrayWrap";
+
+    short[] shortArray = {11,12,13,14,15};
+    String shortArrayName = "shortArray";
+
+    Short[] shortArrayWrap = {16,17,18,19,20};
+    String shortArrayWrapName = "shortArrayWrap";
+
+    int[] intArray = {-2147483648};
+    String intArrayName = "intArray";
+
+    Integer[] intArrayWrap = {2147483647};
+    String intArrayWrapName = "intArrayWrap";
+
+    char[] charArray = {'j','k','l'};
+    String charArrayName = "charArray";
+
+    Character[] charArrayWrap = {'m','n','o'};
+    String charArrayWrapName = "charArrayWrap";
+
+    String[] inLongArray = {"-9223372036854775807l",
+                            "9223372036854775807L",
+                            "-0l",
+                            "0L",
+                            "-3.402823e38",
+                            "0.0",
+                            "al"}
+    long[] longArray = getLongArray(inLongArray);
+    String longArrayName = "longArray";
+
+    String[] inLongArrayWrap = {"-9223372036854775807l",
+                                "9223372036854775807L",
+                                "-0l",
+                                "0L",
+                                "-3.402823e38",
+                                "-0.0",
+                                "aL"};
+    Long[] longArrayWrap = getLongArrayWrap(inLongArrayWrap);
+    String longArrayWrapName = "longArrayWrap";
+
+    String[] inFloatArray = {"-82233720368547758080000001f",
+                            "100.0F",
+                            "-123456789012345678901234567890123456789f",
+                            "123456789012345678901234567890123456789F",
+                            "-3.402823e38",
+                            "0.0",
+                            "af"};
+    float[] floatArray = getFloatArray(inFloatArray);
+    String floatArrayName = "floatArray";
+
+
+    String[] inFloatArrayWrap = {"-1234567890123456789012345678901234567890.79769313486232d",
+                                "1000.0D",
+                                "-123456789012345678901234567890123456789d",
+                                "123456789012345678901234567890123456789D",
+                                "-3.402823e300d",
+                                "-0.0",
+                                "aF"};
+    Float[] floatArrayWrap = getFloatArrayWrap(inFloatArrayWrap);
+    String floatArrayWrapName = "floatArrayWrap";
+
+
+    String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232d",
+                            "1000.0D",
+                            "1234567890123456789012345678901234567890123456789012345678901234567890D",
+                            "-2.12345678901234d",
+                            "3.402823e307D",
+                            "0.0",
+                            "ad"};
+    double[] doubleArray = getDoubleArray(inDoubleArray);
+    String doubleArrayName = "doubleArray";
+
+
+    String[] inDoubleArrayWrap = {"-1234567890123456789012345678901234567890.79769313486232d",
+                                "1000.0D",
+                                "1234567890123456789012345678901234567890123456789012345678901234567890D",
+                                "-2.12345678901234d",
+                                "3.402823e307D",
+                                "-0.0",
+                                "aD"};
+    Double[] doubleArrayWrap = getDoubleArrayWrap(inDoubleArrayWrap);
+    String doubleArrayWrapName = "doubleArrayWrap";
+
+    String[] inBigIntegerArray = {"-8223372036854775808000000182233720368547758000182233720368547758080000001",
+            "9542233720368547758080000001822334563456435643720367867865758000182233720352345368547758080000001",
+            "100.0",
+            "0",
+            "-0",
+            "abc"};
+    BigInteger[] bigIntegerArray = getBigIntegerArray(inBigIntegerArray);
+    String bigIntegerArrayName = "bigIntegerArray";
+
+    String[] inBigDecimalArray = {"-8223372036854775808000000182233720368547758000182233720368547758080000001.8000182233720368547758080000001",
+            "954223372036854775808000000135643720367867865758000182233720352345368547758080000001.58000182233720352345368547758080000001",
+            "100.0",
+            "0",
+            "-0",
+            "abc"};
+    BigDecimal[] bigDecimalArray = getBigDecimalArray(inBigDecimalArray);
+    String bigDecimalArrayName = "bigDecimalArray";
+
+    //2024-02-28T00:00-06:00[America/Mexico_City]
+    String[] inZonedDateTimeArray = {"28/02/2024 00:00",
+                                    "28/02/2024 23:59",
+                                    "30/02/2024 00:00",
+                                    "28/03/2024 25:00",
+                                    "28/04/2024 23:70",
+                                    "00/00/0000 00:00",
+                                    "12345",
+                                    "100.100",
+                                    "abc"};
+    String zonedDateTimeArrayFormat = "dd/MM/yyyy HH:mm";
+    ZonedDateTime[] zonedDateTimeArray = getZonedDateTimeArray(inZonedDateTimeArray,zonedDateTimeArrayFormat);
+    String zonedDateTimeArrayName = "zonedDateTimeArray";
+
+    //2024-02-28T00:00-06:00[America/Mexico_City]
+    String[] inZonedDateTimeArray2 = {"2024-02-28 00:00",
+            "2024-02-28 23:59",
+            "2024-02-30 00:00",
+            "2024-03-28 25:00",
+            "2024-04-28 23:70",
+            "0000-00-00 00:00",
+            "12345",
+            "100.100",
+            "abc"};
+    String zonedDateTimeArray2Format = "yyyy-MM-dd HH:mm";
+    ZonedDateTime[] zonedDateTimeArray2 = getZonedDateTimeArray(inZonedDateTimeArray2,zonedDateTimeArray2Format);
+    String zonedDateTimeArray2Name = "zonedDateTimeArray2";
+
+
+    //Wed Feb 28 00:00:00 CST 2024
+    String[] inDateArray = {"28/02/2024",
+            "28/02/2024",
+            "30/02/2024",
+            "28/03/2024",
+            "28/04/2024",
+            "00/00/0000",
+            "12345",
+            "100.100",
+            "abc"};
+    String dateArrayFormat = "dd/MM/yyyy";
+    Date[] dateArray = getDateArray(inDateArray,dateArrayFormat);
+    String dateArrayName = "dateArray";
+
+    public ArrayDataTypesBuilder setStringArray(final String[] stringArray) {
+        this.stringArray = stringArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setBooleanArray(final boolean[] booleanArray) {
+        this.booleanArray = booleanArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setBooleanArrayWrap(final Boolean[] booleanArrayWrap) {
+        this.booleanArrayWrap = booleanArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setByteArray(final byte[] byteArray) {
+        this.byteArray = byteArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setByteArrayWrap(final Byte[] byteArrayWrap) {
+        this.byteArrayWrap = byteArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setShortArray(final short[] shortArray) {
+        this.shortArray = shortArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setShortArrayWrap(final Short[] shortArrayWrap) {
+        this.shortArrayWrap = shortArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setIntArray(final int[] intArray) {
+        this.intArray = intArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setIntArrayWrap(final Integer[] intArrayWrap) {
+        this.intArrayWrap = intArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setCharArray(final char[] charArray) {
+        this.charArray = charArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setCharArrayWrap(final Character[] charArrayWrap) {
+        this.charArrayWrap = charArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setLongArray(final long[] longArray) {
+        this.longArray = longArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setLongArrayWrap(final Long[] longArrayWrap) {
+        this.longArrayWrap = longArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setFloatArray(final float[] floatArray) {
+        this.floatArray = floatArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setFloatArrayWrap(final Float[] floatArrayWrap) {
+        this.floatArrayWrap = floatArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setDoubleArray(final double[] doubleArray) {
+        this.doubleArray = doubleArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setDoubleArrayWrap(final Double[] doubleArrayWrap) {
+        this.doubleArrayWrap = doubleArrayWrap;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setBigIntegerArray(final BigInteger[] bigIntegerArray) {
+        this.bigIntegerArray = bigIntegerArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setBigDecimalArray(final BigDecimal[] bigDecimalArray) {
+        this.bigDecimalArray = bigDecimalArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setZonedDateTimeArray(final ZonedDateTime[] zonedDateTimeArray) {
+        this.zonedDateTimeArray = zonedDateTimeArray;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setZonedDateTimeArray2(final ZonedDateTime[] zonedDateTimeArray2) {
+        this.zonedDateTimeArray2 = zonedDateTimeArray2;
+        return this;
+    }
+
+    public ArrayDataTypesBuilder setDateArray(final Date[] dateArray) {
+        this.dateArray = dateArray;
+        return this;
+    }
+
+    public DslPart build() {
+        PactDslJsonBody pactDslJsonBody = new PactDslJsonBody();
+
+        if (Objects.nonNull(stringArray)) {
+            pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray();
+        }
+
+        if (Objects.nonNull(booleanArray)) {
+            pactDslJsonBody.array(booleanArrayName).stringValue(Arrays.toString(booleanArray)).closeArray();
+        }
+
+        if (Objects.nonNull(booleanArrayWrap)) {
+            pactDslJsonBody.array(booleanArrayWrapName).stringValue(Arrays.toString(booleanArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(byteArray)) {
+            pactDslJsonBody.array(byteArrayName).stringValue(Arrays.toString(byteArray)).closeArray();
+        }
+
+        if (Objects.nonNull(byteArrayWrap)) {
+            pactDslJsonBody.array(byteArrayWrapName).stringValue(Arrays.toString(byteArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(shortArray)) {
+            pactDslJsonBody.array(shortArrayName).stringValue(Arrays.toString(shortArray)).closeArray();
+        }
+
+        if (Objects.nonNull(shortArrayWrap)) {
+            pactDslJsonBody.array(shortArrayWrapName).stringValue(Arrays.toString(shortArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(intArray)) {
+            pactDslJsonBody.array(intArrayName).stringValue(Arrays.toString(intArray)).closeArray();
+        }
+
+        if (Objects.nonNull(intArrayWrap)) {
+            pactDslJsonBody.array(intArrayWrapName).stringValue(Arrays.toString(intArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(charArray)) {
+            pactDslJsonBody.array(charArrayName).stringValue(Arrays.toString(charArray)).closeArray();
+        }
+
+        if (Objects.nonNull(charArrayWrap)) {
+            pactDslJsonBody.array(charArrayWrapName).stringValue(Arrays.toString(charArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(longArray)) {
+            pactDslJsonBody.array(longArrayName).stringValue(Arrays.toString(longArray)).closeArray();
+        }
+
+        if (Objects.nonNull(longArrayWrap)) {
+            pactDslJsonBody.array(longArrayWrapName).stringValue(Arrays.toString(longArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(floatArray)) {
+            pactDslJsonBody.array(floatArrayName).stringValue(Arrays.toString(floatArray)).closeArray();
+        }
+
+        if (Objects.nonNull(floatArrayWrap)) {
+            pactDslJsonBody.array(floatArrayWrapName).stringValue(Arrays.toString(floatArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(doubleArray)) {
+            pactDslJsonBody.array(doubleArrayName).stringValue(Arrays.toString(doubleArray)).closeArray();
+        }
+
+        if (Objects.nonNull(doubleArrayWrap)) {
+            pactDslJsonBody.array(doubleArrayWrapName).stringValue(Arrays.toString(doubleArrayWrap)).closeArray();
+        }
+
+        if (Objects.nonNull(bigIntegerArray)) {
+            pactDslJsonBody.array(bigIntegerArrayName).stringValue(Arrays.toString(bigIntegerArray)).closeArray();
+        }
+
+        if (Objects.nonNull(bigDecimalArray)) {
+            pactDslJsonBody.array(bigDecimalArrayName).stringValue(Arrays.toString(bigDecimalArray)).closeArray();
+        }
+
+        if (Objects.nonNull(zonedDateTimeArray)) {
+            pactDslJsonBody.array(zonedDateTimeArrayName).stringValue(Arrays.toString(zonedDateTimeArray)).closeArray();
+        }
+
+        if (Objects.nonNull(zonedDateTimeArray2)) {
+            pactDslJsonBody.array(zonedDateTimeArray2Name).stringValue(Arrays.toString(zonedDateTimeArray2)).closeArray();
+        }
+
+        if (Objects.nonNull(dateArray)) {
+            pactDslJsonBody.array(dateArrayName).stringValue(Arrays.toString(dateArray)).closeArray();
+        }
+        return pactDslJsonBody;
+    }
+
+    public ArrayDataTypes buildExpectedInstance() {
+        ArrayDataTypes object = new ArrayDataTypes();
+        object.setStringArray(this.stringArray);
+        object.setBooleanArray(this.booleanArray);
+        object.setBooleanArrayWrap(this.booleanArrayWrap);
+        object.setByteArray(this.byteArray);
+        object.setByteArrayWrap(this.byteArrayWrap);
+        object.setShortArray(this.shortArray);
+        object.setShortArrayWrap(this.shortArrayWrap);
+        object.setIntArray(this.intArray);
+        object.setIntArrayWrap(this.intArrayWrap);
+        object.setCharArray(this.charArray);
+        object.setCharArrayWrap(this.charArrayWrap);
+        object.setLongArray(this.longArray);
+        object.setLongArrayWrap(this.longArrayWrap);
+        object.setFloatArray(this.floatArray);
+        object.setFloatArrayWrap(this.floatArrayWrap);
+        object.setDoubleArray(this.doubleArray);
+        object.setDoubleArrayWrap(this.doubleArrayWrap);
+        object.setBigIntegerArray(this.bigIntegerArray);
+        object.setBigDecimalArray(this.bigDecimalArray);
+        object.setZonedDateTimeArray(this.zonedDateTimeArray);
+        object.setZonedDateTimeArray2(this.zonedDateTimeArray2);
+        object.setDateArray(this.dateArray);
+        return object;
+    }
+
+    private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
+    }
+
+    public static long[] getLongArray(String[] numbers) {
+        long[] result = new long[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = Long.parseLong(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("long value expected but was: "+numbers[i]);
+                result[i] = 0l;
+            }
+        return result;
+    }
+
+    public static Long[] getLongArrayWrap(String[] numbers) {
+        Long[] result = new Long[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = Long.parseLong(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("Long value expected but was: "+numbers[i]);
+                result[i] = 0L;
+            }
+        return result;
+    }
+
+    public static float[] getFloatArray(String[] numbers) {
+        float[] result = new float[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = Float.parseFloat(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("float value expected but was: "+numbers[i]);
+                result[i] = 0.0f;
+            }
+        return result;
+    }
+
+    public static Float[] getFloatArrayWrap(String[] numbers) {
+        Float[] result = new Float[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = Float.parseFloat(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("Float value expected but was: "+numbers[i]);
+                result[i] = 0.0F;
+            }
+        return result;
+    }
+
+    public static double[] getDoubleArray(String[] numbers) {
+        double[] result = new double[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = Double.parseDouble(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("double value expected but was: "+numbers[i]);
+                result[i] = 0.0d;
+            }
+        return result;
+    }
+
+    public static Double[] getDoubleArrayWrap(String[] numbers) {
+        Double[] result = new Double[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = Double.parseDouble(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("Double value expected but was: "+numbers[i]);
+                result[i] = 0.0D;
+            }
+        return result;
+    }
+
+    public static BigInteger[] getBigIntegerArray(String[] numbers) {
+        BigInteger[] result = new BigInteger[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = new BigInteger(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("BigInteger value expected but was: "+numbers[i]);
+                result[i] = new BigInteger("0");
+            }
+        return result;
+    }
+
+    public static BigDecimal[] getBigDecimalArray(String[] numbers) {
+        BigDecimal[] result = new BigDecimal[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try { result[i] = new BigDecimal(numbers[i]);
+            } catch (NumberFormatException nfe) {
+                System.out.println("BigDecimal value expected but was: "+numbers[i]);
+                result[i] = new BigDecimal("0.0");
+            }
+        return result;
+    }
+
+    public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) {
+        ZonedDateTime[] result = new ZonedDateTime[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try {
+                result[i] = LocalDateTime
+                        .parse(numbers[i],DateTimeFormatter.ofPattern(format))
+                        .atZone(ZoneId.systemDefault())
+                        .withZoneSameInstant(ZoneId.systemDefault());
+
+            } catch (DateTimeException dte) {
+                System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+                System.out.println("    "+dte.getMessage());
+                result[i] = ZonedDateTime.now();
+            }
+        return result;
+    }
+
+    public static Date[] getDateArray(String[] numbers, String format) {
+        Date[] result = new Date[numbers.length];
+        for (int i = 0; i < numbers.length; i++)
+            try {
+                result[i] = new SimpleDateFormat(format).parse(numbers[i]);
+            } catch (Exception dte) {
+                System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+                System.out.println("    "+dte.getMessage());
+                result[i] = new Date();
+            }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/basic/CharacterDataTypesBuilder.java b/src/test/resources/basic/CharacterDataTypesBuilder.java
index 6f3cec0..d6a52b4 100644
--- a/src/test/resources/basic/CharacterDataTypesBuilder.java
+++ b/src/test/resources/basic/CharacterDataTypesBuilder.java
@@ -7,6 +7,9 @@
 import java.text.SimpleDateFormat;
 import java.time.Instant;
 import java.time.LocalDate;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Date;
@@ -19,6 +22,7 @@
 import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
 import com.sngular.annotation.processor.mapping.CustomDslModifier;
 import com.sngular.resources.basic.CharacterDataTypes;
+import java.util.Arrays;
 
 public class CharacterDataTypesBuilder {
   String name = "nameExample";
@@ -93,5 +97,122 @@ public CharacterDataTypes buildExpectedInstance() {
 
   private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
   }
-}
 
+  public static long[] getLongArray(String[] numbers) {
+    long[] result = new long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("long value expected but was: "+numbers[i]);
+        result[i] = 0l;
+      }
+    return result;
+  }
+
+  public static Long[] getLongArrayWrap(String[] numbers) {
+    Long[] result = new Long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Long value expected but was: "+numbers[i]);
+        result[i] = 0L;
+      }
+    return result;
+  }
+
+  public static float[] getFloatArray(String[] numbers) {
+    float[] result = new float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("float value expected but was: "+numbers[i]);
+        result[i] = 0.0f;
+      }
+    return result;
+  }
+
+  public static Float[] getFloatArrayWrap(String[] numbers) {
+    Float[] result = new Float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Float value expected but was: "+numbers[i]);
+        result[i] = 0.0F;
+      }
+    return result;
+  }
+
+  public static double[] getDoubleArray(String[] numbers) {
+    double[] result = new double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("double value expected but was: "+numbers[i]);
+        result[i] = 0.0d;
+      }
+    return result;
+  }
+
+  public static Double[] getDoubleArrayWrap(String[] numbers) {
+    Double[] result = new Double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Double value expected but was: "+numbers[i]);
+        result[i] = 0.0D;
+      }
+    return result;
+  }
+
+  public static BigInteger[] getBigIntegerArray(String[] numbers) {
+    BigInteger[] result = new BigInteger[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigInteger(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigInteger value expected but was: "+numbers[i]);
+        result[i] = new BigInteger("0");
+      }
+    return result;
+  }
+
+  public static BigDecimal[] getBigDecimalArray(String[] numbers) {
+    BigDecimal[] result = new BigDecimal[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigDecimal(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigDecimal value expected but was: "+numbers[i]);
+        result[i] = new BigDecimal("0.0");
+      }
+    return result;
+  }
+
+  public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) {
+    ZonedDateTime[] result = new ZonedDateTime[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = LocalDateTime
+                .parse(numbers[i],DateTimeFormatter.ofPattern(format))
+                .atZone(ZoneId.systemDefault())
+                .withZoneSameInstant(ZoneId.systemDefault());
+
+      } catch (DateTimeException dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = ZonedDateTime.now();
+      }
+    return result;
+  }
+
+  public static Date[] getDateArray(String[] numbers, String format) {
+    Date[] result = new Date[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = new SimpleDateFormat(format).parse(numbers[i]);
+      } catch (Exception dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = new Date();
+      }
+    return result;
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/basic/NumericDataTypesBuilder.java b/src/test/resources/basic/NumericDataTypesBuilder.java
index 31acc8b..491ac8b 100644
--- a/src/test/resources/basic/NumericDataTypesBuilder.java
+++ b/src/test/resources/basic/NumericDataTypesBuilder.java
@@ -7,6 +7,9 @@
 import java.text.SimpleDateFormat;
 import java.time.Instant;
 import java.time.LocalDate;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Date;
@@ -19,6 +22,7 @@
 import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
 import com.sngular.annotation.processor.mapping.CustomDslModifier;
 import com.sngular.resources.basic.NumericDataTypes;
+import java.util.Arrays;
 
 public class NumericDataTypesBuilder {
 
@@ -122,18 +126,23 @@ public NumericDataTypesBuilder setBigDecimalObject(final BigDecimal bigDecimalOb
 
   public DslPart build() {
     PactDslJsonBody pactDslJsonBody = new PactDslJsonBody();
+
     if (Objects.nonNull(integer)) {
       pactDslJsonBody.integerType("integer", integer);
     }
+
     if (Objects.nonNull(primitiveInt)) {
       pactDslJsonBody.integerType("primitiveInt", primitiveInt);
     }
+
     if (Objects.nonNull(longObject)) {
       pactDslJsonBody.integerType("longObject", longObject);
     }
+
     if (Objects.nonNull(primitiveLong)) {
       pactDslJsonBody.integerType("primitiveLong", primitiveLong);
     }
+
     if (Objects.nonNull(floatObject)) {
       pactDslJsonBody.decimalType("floatObject", (double) floatObject);
     }
@@ -193,9 +202,127 @@ public NumericDataTypes buildExpectedInstance() {
     object.setPrimitiveByte(this.primitiveByte);
     object.setBigIntegerObject(this.bigIntegerObject);
     object.setBigDecimalObject(this.bigDecimalObject);
-
     return object;
   }
+
   private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
   }
+
+  public static long[] getLongArray(String[] numbers) {
+    long[] result = new long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("long value expected but was: "+numbers[i]);
+        result[i] = 0l;
+      }
+    return result;
+  }
+
+  public static Long[] getLongArrayWrap(String[] numbers) {
+    Long[] result = new Long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Long value expected but was: "+numbers[i]);
+        result[i] = 0L;
+      }
+    return result;
+  }
+
+  public static float[] getFloatArray(String[] numbers) {
+    float[] result = new float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("float value expected but was: "+numbers[i]);
+        result[i] = 0.0f;
+      }
+    return result;
+  }
+
+  public static Float[] getFloatArrayWrap(String[] numbers) {
+    Float[] result = new Float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Float value expected but was: "+numbers[i]);
+        result[i] = 0.0F;
+      }
+    return result;
+  }
+
+  public static double[] getDoubleArray(String[] numbers) {
+    double[] result = new double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("double value expected but was: "+numbers[i]);
+        result[i] = 0.0d;
+      }
+    return result;
+  }
+
+  public static Double[] getDoubleArrayWrap(String[] numbers) {
+    Double[] result = new Double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Double value expected but was: "+numbers[i]);
+        result[i] = 0.0D;
+      }
+    return result;
+  }
+
+  public static BigInteger[] getBigIntegerArray(String[] numbers) {
+    BigInteger[] result = new BigInteger[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigInteger(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigInteger value expected but was: "+numbers[i]);
+        result[i] = new BigInteger("0");
+      }
+    return result;
+  }
+
+  public static BigDecimal[] getBigDecimalArray(String[] numbers) {
+    BigDecimal[] result = new BigDecimal[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigDecimal(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigDecimal value expected but was: "+numbers[i]);
+        result[i] = new BigDecimal("0.0");
+      }
+    return result;
+  }
+
+  public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) {
+    ZonedDateTime[] result = new ZonedDateTime[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = LocalDateTime
+                .parse(numbers[i],DateTimeFormatter.ofPattern(format))
+                .atZone(ZoneId.systemDefault())
+                .withZoneSameInstant(ZoneId.systemDefault());
+
+      } catch (DateTimeException dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = ZonedDateTime.now();
+      }
+    return result;
+  }
+
+  public static Date[] getDateArray(String[] numbers, String format) {
+    Date[] result = new Date[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = new SimpleDateFormat(format).parse(numbers[i]);
+      } catch (Exception dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = new Date();
+      }
+    return result;
+  }
 }
\ No newline at end of file
diff --git a/src/test/resources/date/DateDataTypesBuilder.java b/src/test/resources/date/DateDataTypesBuilder.java
index bfb096e..938749b 100644
--- a/src/test/resources/date/DateDataTypesBuilder.java
+++ b/src/test/resources/date/DateDataTypesBuilder.java
@@ -7,6 +7,9 @@
 import java.text.SimpleDateFormat;
 import java.time.Instant;
 import java.time.LocalDate;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Date;
@@ -19,8 +22,7 @@
 import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
 import com.sngular.annotation.processor.mapping.CustomDslModifier;
 import com.sngular.annotation.examples.DateDataTypes;
-
-
+import java.util.Arrays;
 public class DateDataTypesBuilder {
   ZonedDateTime formattedZoneDateTime = ZonedDateTime.parse("23/04/2023 12:00",  DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"));
   ZonedDateTime defaultFormatZoneDateTime = ZonedDateTime.parse("2023-12-03T10:15:30+01:00[Europe/Madrid]",  DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss[.SSSSSS][.SSS]XXX['['VV']']"));
@@ -71,8 +73,125 @@ public DateDataTypes buildExpectedInstance() {
     object.setFormattedDate(this.formattedDate);
     return object;
   }
+
   private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
   }
 
-}
+  public static long[] getLongArray(String[] numbers) {
+    long[] result = new long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("long value expected but was: "+numbers[i]);
+        result[i] = 0l;
+      }
+    return result;
+  }
+
+  public static Long[] getLongArrayWrap(String[] numbers) {
+    Long[] result = new Long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Long value expected but was: "+numbers[i]);
+        result[i] = 0L;
+      }
+    return result;
+  }
+
+  public static float[] getFloatArray(String[] numbers) {
+    float[] result = new float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("float value expected but was: "+numbers[i]);
+        result[i] = 0.0f;
+      }
+    return result;
+  }
+
+  public static Float[] getFloatArrayWrap(String[] numbers) {
+    Float[] result = new Float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Float value expected but was: "+numbers[i]);
+        result[i] = 0.0F;
+      }
+    return result;
+  }
+
+  public static double[] getDoubleArray(String[] numbers) {
+    double[] result = new double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("double value expected but was: "+numbers[i]);
+        result[i] = 0.0d;
+      }
+    return result;
+  }
+
+  public static Double[] getDoubleArrayWrap(String[] numbers) {
+    Double[] result = new Double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Double value expected but was: "+numbers[i]);
+        result[i] = 0.0D;
+      }
+    return result;
+  }
 
+  public static BigInteger[] getBigIntegerArray(String[] numbers) {
+    BigInteger[] result = new BigInteger[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigInteger(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigInteger value expected but was: "+numbers[i]);
+        result[i] = new BigInteger("0");
+      }
+    return result;
+  }
+
+  public static BigDecimal[] getBigDecimalArray(String[] numbers) {
+    BigDecimal[] result = new BigDecimal[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigDecimal(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigDecimal value expected but was: "+numbers[i]);
+        result[i] = new BigDecimal("0.0");
+      }
+    return result;
+  }
+
+  public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) {
+    ZonedDateTime[] result = new ZonedDateTime[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = LocalDateTime
+                .parse(numbers[i],DateTimeFormatter.ofPattern(format))
+                .atZone(ZoneId.systemDefault())
+                .withZoneSameInstant(ZoneId.systemDefault());
+
+      } catch (DateTimeException dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = ZonedDateTime.now();
+      }
+    return result;
+  }
+
+  public static Date[] getDateArray(String[] numbers, String format) {
+    Date[] result = new Date[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = new SimpleDateFormat(format).parse(numbers[i]);
+      } catch (Exception dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = new Date();
+      }
+    return result;
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/random/NumericDataTypes.java b/src/test/resources/random/NumericDataTypes.java
deleted file mode 100644
index f063ab3..0000000
--- a/src/test/resources/random/NumericDataTypes.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package com.sngular.annotation.examples;
-
-import com.sngular.annotation.pact.Example;
-import com.sngular.annotation.pact.PactDslBodyBuilder;
-
-@PactDslBodyBuilder
-public class NumericDataTypes {
-
-  private int age;
-
-  protected int getAge() {
-    return age;
-  }
-
-  protected void setAge(final int age) {
-    this.age = age;
-  }
-}
\ No newline at end of file
diff --git a/src/test/resources/random/NumericDataTypesBuilder.java b/src/test/resources/random/NumericDataTypesBuilder.java
deleted file mode 100644
index 61cd59c..0000000
--- a/src/test/resources/random/NumericDataTypesBuilder.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package com.sngular.annotation.examples;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.ZonedDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.Date;
-import java.util.List;
-import java.util.Objects;
-
-import au.com.dius.pact.consumer.dsl.DslPart;
-import au.com.dius.pact.consumer.dsl.PactDslJsonArray;
-import au.com.dius.pact.consumer.dsl.PactDslJsonBody;
-import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
-import com.sngular.annotation.processor.mapping.CustomDslModifier;
-import com.sngular.annotation.examples.NumericDataTypes;
-
-public class NumericDataTypesBuilder {
-  int age = 0;
-
-  public NumericDataTypesBuilder setAge(final int age) {
-    this.age = age;
-    return this;
-  }
-
-  public DslPart build() {
-    PactDslJsonBody pactDslJsonBody = new PactDslJsonBody();
-    if (Objects.nonNull(age)) {
-      pactDslJsonBody.integerType("age", age);
-    }
-
-    return pactDslJsonBody;
-  }
-  public NumericDataTypes buildExpectedInstance() {
-    NumericDataTypes object = new NumericDataTypes();
-    object.setAge(this.age);
-    return object;
-  }
-  private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
-  }
-
-}
-
diff --git a/src/test/resources/random/RandomValueGeneration.java b/src/test/resources/random/RandomValueGeneration.java
new file mode 100644
index 0000000..3461388
--- /dev/null
+++ b/src/test/resources/random/RandomValueGeneration.java
@@ -0,0 +1,363 @@
+package com.sngular.annotation.examples;
+
+import com.sngular.annotation.pact.Example;
+import com.sngular.annotation.pact.PactDslBodyBuilder;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.ZonedDateTime;
+import java.util.Date;
+
+@PactDslBodyBuilder
+public class RandomValueGeneration {
+
+  public Integer integer;
+
+  public int primitiveInt;
+
+  public Long longObject;
+
+  public long primitiveLong;
+
+  public Float floatObject;
+
+  public float primitiveFloat;
+
+  public Double doubleObject;
+
+  public double primitiveDouble;
+
+  public Short shortObject;
+
+  public short primitiveShort;
+
+  public Byte byteObject;
+
+  public byte primitiveByte;
+
+  public BigInteger bigIntegerObject;
+
+  public BigDecimal bigDecimalObject;
+
+  public String[] stringArray;
+
+  public boolean[] booleanArray;
+
+  public Boolean[] booleanArrayWrap;
+
+  public byte[] byteArray;
+
+  public Byte[] byteArrayWrap;
+
+  public short[] shortArray;
+
+  public Short[] shortArrayWrap;
+
+  public int[] intArray;
+
+  public Integer[] intArrayWrap;
+
+  public char[] charArray;
+
+  public Character[] charArrayWrap;
+
+  long[] longArray;
+
+  Long[] longArrayWrap;
+
+  float[] floatArray;
+
+  Float[] floatArrayWrap;
+
+  double[] doubleArray;
+
+  Double[] doubleArrayWrap;
+
+  BigInteger[] bigIntegerArray;
+
+  BigDecimal[] bigDecimalArray;
+
+  ZonedDateTime[] zonedDateTimeArray;
+
+  Date[] dateArray;
+
+  public Integer getInteger() {
+    return integer;
+  }
+
+  public void setInteger(final Integer integer) {
+    this.integer = integer;
+  }
+
+  public int getPrimitiveInt() {
+    return primitiveInt;
+  }
+
+  public void setPrimitiveInt(final int primitiveInt) {
+    this.primitiveInt = primitiveInt;
+  }
+
+  public Long getLongObject() {
+    return longObject;
+  }
+
+  public void setLongObject(final Long longObject) {
+    this.longObject = longObject;
+  }
+
+  public long getPrimitiveLong() {
+    return primitiveLong;
+  }
+
+  public void setPrimitiveLong(final long primitiveLong) {
+    this.primitiveLong = primitiveLong;
+  }
+
+  public Float getFloatObject() {
+    return floatObject;
+  }
+
+  public void setFloatObject(Float floatObject) {
+    this.floatObject = floatObject;
+  }
+
+  public float getPrimitiveFloat() {
+    return primitiveFloat;
+  }
+
+  public void setPrimitiveFloat(float primitiveFloat) {
+    this.primitiveFloat = primitiveFloat;
+  }
+
+  public Double getDoubleObject() {
+    return doubleObject;
+  }
+
+  public void setDoubleObject(Double doubleObject) {
+    this.doubleObject = doubleObject;
+  }
+
+  public double getPrimitiveDouble() {
+    return primitiveDouble;
+  }
+
+  public void setPrimitiveDouble(double primitiveDouble) {
+    this.primitiveDouble = primitiveDouble;
+  }
+
+  public Short getShortObject() {
+    return shortObject;
+  }
+
+  public void setShortObject(Short shortObject) {
+    this.shortObject = shortObject;
+  }
+
+  public short getPrimitiveShort() {
+    return primitiveShort;
+  }
+
+  public void setPrimitiveShort(short primitiveShort) {
+    this.primitiveShort = primitiveShort;
+  }
+
+  public Byte getByteObject() {
+    return byteObject;
+  }
+
+  public void setByteObject(Byte byteObject) {
+    this.byteObject = byteObject;
+  }
+
+  public byte getPrimitiveByte() {
+    return primitiveByte;
+  }
+
+  public void setPrimitiveByte(byte primitiveByte) {
+    this.primitiveByte = primitiveByte;
+  }
+
+  public BigInteger getBigIntegerObject() {
+    return bigIntegerObject;
+  }
+
+  public void setBigIntegerObject(BigInteger bigIntegerObject) {
+    this.bigIntegerObject = bigIntegerObject;
+  }
+
+  public BigDecimal getBigDecimalObject() {
+    return bigDecimalObject;
+  }
+
+  public void setBigDecimalObject(BigDecimal bigDecimalObject) {
+    this.bigDecimalObject = bigDecimalObject;
+  }
+
+  public String[] getStringArray() {
+    return stringArray;
+  }
+
+  public void setStringArray(String[] stringArray) {
+    this.stringArray = stringArray;
+  }
+
+  public boolean[] getBooleanArray() {
+    return booleanArray;
+  }
+
+  public void setBooleanArray(boolean[] booleanArray) {
+    this.booleanArray = booleanArray;
+  }
+
+  public Boolean[] getBooleanArrayWrap() {
+    return booleanArrayWrap;
+  }
+
+  public void setBooleanArrayWrap(Boolean[] booleanArrayWrap) {
+    this.booleanArrayWrap = booleanArrayWrap;
+  }
+
+  public byte[] getByteArray() {
+    return byteArray;
+  }
+
+  public void setByteArray(byte[] byteArray) {
+    this.byteArray = byteArray;
+  }
+
+  public Byte[] getByteArrayWrap() {
+    return byteArrayWrap;
+  }
+
+  public void setByteArrayWrap(Byte[] byteArrayWrap) {
+    this.byteArrayWrap = byteArrayWrap;
+  }
+
+  public short[] getShortArray() {
+    return shortArray;
+  }
+
+  public void setShortArray(short[] shortArray) {
+    this.shortArray = shortArray;
+  }
+
+  public Short[] getShortArrayWrap() {
+    return shortArrayWrap;
+  }
+
+  public void setShortArrayWrap(Short[] shortArrayWrap) {
+    this.shortArrayWrap = shortArrayWrap;
+  }
+
+  public int[] getIntArray() {
+    return intArray;
+  }
+
+  public void setIntArray(int[] intArray) {
+    this.intArray = intArray;
+  }
+
+  public Integer[] getIntArrayWrap() {
+    return intArrayWrap;
+  }
+
+  public void setIntArrayWrap(Integer[] intArrayWrap) {
+    this.intArrayWrap = intArrayWrap;
+  }
+
+  public char[] getCharArray() {
+    return charArray;
+  }
+
+  public void setCharArray(char[] charArray) {
+    this.charArray = charArray;
+  }
+
+  public Character[] getCharArrayWrap() {
+    return charArrayWrap;
+  }
+
+  public void setCharArrayWrap(Character[] charArrayWrap) {
+    this.charArrayWrap = charArrayWrap;
+  }
+
+  public long[] getLongArray() {
+    return longArray;
+  }
+
+  public void setLongArray(long[] longArray) {
+    this.longArray = longArray;
+  }
+
+  public Long[] getLongArrayWrap() {
+    return longArrayWrap;
+  }
+
+  public void setLongArrayWrap(Long[] longArrayWrap) {
+    this.longArrayWrap = longArrayWrap;
+  }
+
+  public float[] getFloatArray() {
+    return floatArray;
+  }
+
+  public void setFloatArray(float[] floatArray) {
+    this.floatArray = floatArray;
+  }
+
+  public Float[] getFloatArrayWrap() {
+    return floatArrayWrap;
+  }
+
+  public void setFloatArrayWrap(Float[] floatArrayWrap) {
+    this.floatArrayWrap = floatArrayWrap;
+  }
+
+  public double[] getDoubleArray() {
+    return doubleArray;
+  }
+
+  public void setDoubleArray(double[] doubleArray) {
+    this.doubleArray = doubleArray;
+  }
+
+  public Double[] getDoubleArrayWrap() {
+    return doubleArrayWrap;
+  }
+
+  public void setDoubleArrayWrap(Double[] doubleArrayWrap) {
+    this.doubleArrayWrap = doubleArrayWrap;
+  }
+
+  public BigInteger[] getBigIntegerArray() {
+    return bigIntegerArray;
+  }
+
+  public void setBigIntegerArray(BigInteger[] bigIntegerArray) {
+    this.bigIntegerArray = bigIntegerArray;
+  }
+
+  public BigDecimal[] getBigDecimalArray() {
+    return bigDecimalArray;
+  }
+
+  public void setBigDecimalArray(BigDecimal[] bigDecimalArray) {
+    this.bigDecimalArray = bigDecimalArray;
+  }
+
+  public ZonedDateTime[] getZonedDateTimeArray() {
+    return zonedDateTimeArray;
+  }
+
+  public void setZonedDateTimeArray(ZonedDateTime[] zonedDateTimeArray) {
+    this.zonedDateTimeArray = zonedDateTimeArray;
+  }
+
+  public Date[] getDateArray() {
+    return dateArray;
+  }
+
+  public void setDateArray(Date[] dateArray) {
+    this.dateArray = dateArray;
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/random/RandomValueGenerationBuilder.java b/src/test/resources/random/RandomValueGenerationBuilder.java
new file mode 100644
index 0000000..d84666e
--- /dev/null
+++ b/src/test/resources/random/RandomValueGenerationBuilder.java
@@ -0,0 +1,614 @@
+package com.sngular.annotation.examples;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+import au.com.dius.pact.consumer.dsl.DslPart;
+import au.com.dius.pact.consumer.dsl.PactDslJsonArray;
+import au.com.dius.pact.consumer.dsl.PactDslJsonBody;
+import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue;
+import com.sngular.annotation.processor.mapping.CustomDslModifier;
+import com.sngular.annotation.examples.RandomValueGeneration;
+import java.util.Arrays;
+
+public class RandomValueGenerationBuilder {
+
+  int integer = 0;
+
+  int primitiveInt = 0;
+
+  long longObject = 0L;
+
+  long primitiveLong = 0L;
+
+  float floatObject = 0.0F;
+
+  float primitiveFloat = 0.0F;
+
+  double doubleObject = 0.0D;
+
+  double primitiveDouble = 0.0D;
+
+  short shortObject = 0;
+
+  short primitiveShort = 0;
+
+  byte byteObject = 0;
+
+  byte primitiveByte = 0;
+
+  BigInteger bigIntegerObject = new BigInteger("0");
+
+  BigDecimal bigDecimalObject = new BigDecimal("0");
+
+  String[] stringArray = {"defaultValue"};
+  String stringArrayName = "stringArray";
+
+  boolean[] booleanArray = {true};
+  String booleanArrayName = "booleanArray";
+
+  Boolean[] booleanArrayWrap = {false};
+  String booleanArrayWrapName = "booleanArrayWrap";
+
+  byte[] byteArray = {-128};
+  String byteArrayName = "byteArray";
+
+  Byte[] byteArrayWrap = {127};
+  String byteArrayWrapName = "byteArrayWrap";
+
+  short[] shortArray = {-32768};
+  String shortArrayName = "shortArray";
+
+  Short[] shortArrayWrap = {32767};
+  String shortArrayWrapName = "shortArrayWrap";
+
+  int[] intArray = {-2147483648};
+  String intArrayName = "intArray";
+
+  Integer[] intArrayWrap = {2147483647};
+  String intArrayWrapName = "intArrayWrap";
+
+  char[] charArray = {'x'};
+  String charArrayName = "charArray";
+
+  Character[] charArrayWrap = {'X'};
+  String charArrayWrapName = "charArrayWrap";
+
+  String[] inLongArray = {"-9223372036854775808l"};
+  long[] longArray = getLongArray(inLongArray);
+  String longArrayName = "longArray";
+
+  String[] inLongArrayWrap = {"9223372036854775807L"};
+  Long[] longArrayWrap = getLongArrayWrap(inLongArrayWrap);
+  String longArrayWrapName = "longArrayWrap";
+
+  String[] inFloatArray = {"-123456789012345678901234567890.402823f"};
+  float[] floatArray = getFloatArray(inFloatArray);
+  String floatArrayName = "floatArray";
+
+  String[] inFloatArrayWrap = {"123456789012345678901234567890.402823F"};
+  Float[] floatArrayWrap = getFloatArrayWrap(inFloatArrayWrap);
+  String floatArrayWrapName = "floatArrayWrap";
+
+  String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232d"};
+  double[] doubleArray = getDoubleArray(inDoubleArray);
+  String doubleArrayName = "doubleArray";
+
+  String[] inDoubleArrayWrap = {"1234567890123456789012345678901234567890.79769313486232D"};
+  Double[] doubleArrayWrap = getDoubleArrayWrap(inDoubleArrayWrap);
+  String doubleArrayWrapName = "doubleArrayWrap";
+
+  String[] inBigIntegerArray = {"12345678901234567890123456789012345678901234567890123456789012345678901234567890"};
+  BigInteger[] bigIntegerArray = getBigIntegerArray(inBigIntegerArray);
+  String bigIntegerArrayName = "bigIntegerArray";
+
+  String[] inBigDecimalArray = {"12345678901234567890123456789012345678901234567890123456789012345678901234567890.901234567890123456789012345678901234567890"};
+  BigDecimal[] bigDecimalArray = getBigDecimalArray(inBigDecimalArray);
+  String bigDecimalArrayName = "bigDecimalArray";
+
+  String[] inZonedDateTimeArray = {"2024-02-28T13:59-06:00[America/Mexico_City]"};
+  String zonedDateTimeArrayFormat = "yyyy-MM-dd'T'HH:mm:ss[.SSSSSS][.SSS]XXX['['VV']']";
+  ZonedDateTime[] zonedDateTimeArray = getZonedDateTimeArray(inZonedDateTimeArray,zonedDateTimeArrayFormat);
+  String zonedDateTimeArrayName = "zonedDateTimeArray";
+
+  String[] inDateArray = {"Wed Feb 28 13:59:00 CST 2024"};
+  String dateArrayFormat = "yyyy-MM-dd";
+  Date[] dateArray = getDateArray(inDateArray,dateArrayFormat);
+  String dateArrayName = "dateArray";
+
+  public RandomValueGenerationBuilder setInteger(final int integer) {
+    this.integer = integer;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setPrimitiveInt(final int primitiveInt) {
+    this.primitiveInt = primitiveInt;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setLongObject(final long longObject) {
+    this.longObject = longObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setPrimitiveLong(final long primitiveLong) {
+    this.primitiveLong = primitiveLong;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setFloatObject(final float floatObject) {
+    this.floatObject = floatObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setPrimitiveFloat(final float primitiveFloat) {
+    this.primitiveFloat = primitiveFloat;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setDoubleObject(final double doubleObject) {
+    this.doubleObject = doubleObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setPrimitiveDouble(final double primitiveDouble) {
+    this.primitiveDouble = primitiveDouble;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setShortObject(final short shortObject) {
+    this.shortObject = shortObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setPrimitiveShort(final short primitiveShort) {
+    this.primitiveShort = primitiveShort;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setByteObject(final byte byteObject) {
+    this.byteObject = byteObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setPrimitiveByte(final byte primitiveByte) {
+    this.primitiveByte = primitiveByte;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setBigIntegerObject(final BigInteger bigIntegerObject) {
+    this.bigIntegerObject = bigIntegerObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setBigDecimalObject(final BigDecimal bigDecimalObject) {
+    this.bigDecimalObject = bigDecimalObject;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setStringArray(final String[] stringArray) {
+    this.stringArray = stringArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setBooleanArray(final boolean[] booleanArray) {
+    this.booleanArray = booleanArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setBooleanArrayWrap(final Boolean[] booleanArrayWrap) {
+    this.booleanArrayWrap = booleanArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setByteArray(final byte[] byteArray) {
+    this.byteArray = byteArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setByteArrayWrap(final Byte[] byteArrayWrap) {
+    this.byteArrayWrap = byteArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setShortArray(final short[] shortArray) {
+    this.shortArray = shortArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setShortArrayWrap(final Short[] shortArrayWrap) {
+    this.shortArrayWrap = shortArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setIntArray(final int[] intArray) {
+    this.intArray = intArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setIntArrayWrap(final Integer[] intArrayWrap) {
+    this.intArrayWrap = intArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setCharArray(final char[] charArray) {
+    this.charArray = charArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setCharArrayWrap(final Character[] charArrayWrap) {
+    this.charArrayWrap = charArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setLongArray(final long[] longArray) {
+    this.longArray = longArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setLongArrayWrap(final Long[] longArrayWrap) {
+    this.longArrayWrap = longArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setFloatArray(final float[] floatArray) {
+    this.floatArray = floatArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setFloatArrayWrap(final Float[] floatArrayWrap) {
+    this.floatArrayWrap = floatArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setDoubleArray(final double[] doubleArray) {
+    this.doubleArray = doubleArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setDoubleArrayWrap(final Double[] doubleArrayWrap) {
+    this.doubleArrayWrap = doubleArrayWrap;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setBigIntegerArray(final BigInteger[] bigIntegerArray) {
+    this.bigIntegerArray = bigIntegerArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setBigDecimalArray(final BigDecimal[] bigDecimalArray) {
+    this.bigDecimalArray = bigDecimalArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setZonedDateTimeArray(final ZonedDateTime[] zonedDateTimeArray) {
+    this.zonedDateTimeArray = zonedDateTimeArray;
+    return this;
+  }
+
+  public RandomValueGenerationBuilder setDateArray(final Date[] dateArray) {
+    this.dateArray = dateArray;
+    return this;
+  }
+
+  public DslPart build() {
+    PactDslJsonBody pactDslJsonBody = new PactDslJsonBody();
+
+    if (Objects.nonNull(integer)) {
+      pactDslJsonBody.integerType("integer", integer);
+    }
+
+    if (Objects.nonNull(primitiveInt)) {
+      pactDslJsonBody.integerType("primitiveInt", primitiveInt);
+    }
+
+    if (Objects.nonNull(longObject)) {
+      pactDslJsonBody.integerType("longObject", longObject);
+    }
+
+    if (Objects.nonNull(primitiveLong)) {
+      pactDslJsonBody.integerType("primitiveLong", primitiveLong);
+    }
+
+    if (Objects.nonNull(floatObject)) {
+      pactDslJsonBody.decimalType("floatObject", (double) floatObject);
+    }
+
+    if (Objects.nonNull(primitiveFloat)) {
+      pactDslJsonBody.decimalType("primitiveFloat", (double) primitiveFloat);
+    }
+
+    if (Objects.nonNull(doubleObject)) {
+      pactDslJsonBody.decimalType("doubleObject", doubleObject);
+    }
+
+    if (Objects.nonNull(primitiveDouble)) {
+      pactDslJsonBody.decimalType("primitiveDouble", primitiveDouble);
+    }
+
+    if (Objects.nonNull(shortObject)) {
+      pactDslJsonBody.integerType("shortObject", (int) shortObject);
+    }
+
+    if (Objects.nonNull(primitiveShort)) {
+      pactDslJsonBody.integerType("primitiveShort", (int) primitiveShort);
+    }
+
+    if (Objects.nonNull(byteObject)) {
+      pactDslJsonBody.integerType("byteObject", (int) byteObject);
+    }
+
+    if (Objects.nonNull(primitiveByte)) {
+      pactDslJsonBody.integerType("primitiveByte", (int) primitiveByte);
+    }
+
+    if (Objects.nonNull(bigIntegerObject)) {
+      pactDslJsonBody.integerType("bigIntegerObject", bigIntegerObject.intValue());
+    }
+
+    if (Objects.nonNull(bigDecimalObject)) {
+      pactDslJsonBody.decimalType("bigDecimalObject", bigDecimalObject);
+    }
+
+    if (Objects.nonNull(stringArray)) {
+      pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray();
+    }
+
+    if (Objects.nonNull(booleanArray)) {
+      pactDslJsonBody.array(booleanArrayName).stringValue(Arrays.toString(booleanArray)).closeArray();
+    }
+
+    if (Objects.nonNull(booleanArrayWrap)) {
+      pactDslJsonBody.array(booleanArrayWrapName).stringValue(Arrays.toString(booleanArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(byteArray)) {
+      pactDslJsonBody.array(byteArrayName).stringValue(Arrays.toString(byteArray)).closeArray();
+    }
+
+    if (Objects.nonNull(byteArrayWrap)) {
+      pactDslJsonBody.array(byteArrayWrapName).stringValue(Arrays.toString(byteArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(shortArray)) {
+      pactDslJsonBody.array(shortArrayName).stringValue(Arrays.toString(shortArray)).closeArray();
+    }
+
+    if (Objects.nonNull(shortArrayWrap)) {
+      pactDslJsonBody.array(shortArrayWrapName).stringValue(Arrays.toString(shortArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(intArray)) {
+      pactDslJsonBody.array(intArrayName).stringValue(Arrays.toString(intArray)).closeArray();
+    }
+
+    if (Objects.nonNull(intArrayWrap)) {
+      pactDslJsonBody.array(intArrayWrapName).stringValue(Arrays.toString(intArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(charArray)) {
+      pactDslJsonBody.array(charArrayName).stringValue(Arrays.toString(charArray)).closeArray();
+    }
+
+    if (Objects.nonNull(charArrayWrap)) {
+      pactDslJsonBody.array(charArrayWrapName).stringValue(Arrays.toString(charArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(longArray)) {
+      pactDslJsonBody.array(longArrayName).stringValue(Arrays.toString(longArray)).closeArray();
+    }
+
+    if (Objects.nonNull(longArrayWrap)) {
+      pactDslJsonBody.array(longArrayWrapName).stringValue(Arrays.toString(longArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(floatArray)) {
+      pactDslJsonBody.array(floatArrayName).stringValue(Arrays.toString(floatArray)).closeArray();
+    }
+
+    if (Objects.nonNull(floatArrayWrap)) {
+      pactDslJsonBody.array(floatArrayWrapName).stringValue(Arrays.toString(floatArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(doubleArray)) {
+      pactDslJsonBody.array(doubleArrayName).stringValue(Arrays.toString(doubleArray)).closeArray();
+    }
+
+    if (Objects.nonNull(doubleArrayWrap)) {
+      pactDslJsonBody.array(doubleArrayWrapName).stringValue(Arrays.toString(doubleArrayWrap)).closeArray();
+    }
+
+    if (Objects.nonNull(bigIntegerArray)) {
+
+      pactDslJsonBody.array(bigIntegerArrayName).stringValue(Arrays.toString(bigIntegerArray)).closeArray();
+    }
+
+    if (Objects.nonNull(bigDecimalArray)) {
+
+      pactDslJsonBody.array(bigDecimalArrayName).stringValue(Arrays.toString(bigDecimalArray)).closeArray();
+    }
+
+    if (Objects.nonNull(zonedDateTimeArray)) {
+      pactDslJsonBody.array(zonedDateTimeArrayName).stringValue(Arrays.toString(zonedDateTimeArray)).closeArray();
+    }
+
+    if (Objects.nonNull(dateArray)) {
+      pactDslJsonBody.array(dateArrayName).stringValue(Arrays.toString(dateArray)).closeArray();
+    }
+    return pactDslJsonBody;
+  }
+
+  public RandomValueGeneration buildExpectedInstance() {
+    RandomValueGeneration object = new RandomValueGeneration();
+    object.setInteger(this.integer);
+    object.setPrimitiveInt(this.primitiveInt);
+    object.setLongObject(this.longObject);
+    object.setPrimitiveLong(this.primitiveLong);
+    object.setFloatObject(this.floatObject);
+    object.setPrimitiveFloat(this.primitiveFloat);
+    object.setDoubleObject(this.doubleObject);
+    object.setPrimitiveDouble(this.primitiveDouble);
+    object.setShortObject(this.shortObject);
+    object.setPrimitiveShort(this.primitiveShort);
+    object.setByteObject(this.byteObject);
+    object.setPrimitiveByte(this.primitiveByte);
+    object.setBigIntegerObject(this.bigIntegerObject);
+    object.setBigDecimalObject(this.bigDecimalObject);
+    object.setStringArray(this.stringArray);
+    object.setBooleanArray(this.booleanArray);
+    object.setBooleanArrayWrap(this.booleanArrayWrap);
+    object.setByteArray(this.byteArray);
+    object.setByteArrayWrap(this.byteArrayWrap);
+    object.setShortArray(this.shortArray);
+    object.setShortArrayWrap(this.shortArrayWrap);
+    object.setIntArray(this.intArray);
+    object.setIntArrayWrap(this.intArrayWrap);
+    object.setCharArray(this.charArray);
+    object.setCharArrayWrap(this.charArrayWrap);
+    object.setLongArray(this.longArray);
+    object.setLongArrayWrap(this.longArrayWrap);
+    object.setFloatArray(this.floatArray);
+    object.setFloatArrayWrap(this.floatArrayWrap);
+    object.setDoubleArray(this.doubleArray);
+    object.setDoubleArrayWrap(this.doubleArrayWrap);
+    object.setBigIntegerArray(this.bigIntegerArray);
+    object.setBigDecimalArray(this.bigDecimalArray);
+    object.setZonedDateTimeArray(this.zonedDateTimeArray);
+    object.setDateArray(this.dateArray);
+    return object;
+  }
+
+  private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
+  }
+
+  public static long[] getLongArray(String[] numbers) {
+    long[] result = new long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("long value expected but was: "+numbers[i]);
+        result[i] = 0l;
+      }
+    return result;
+  }
+
+  public static Long[] getLongArrayWrap(String[] numbers) {
+    Long[] result = new Long[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Long.parseLong(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Long value expected but was: "+numbers[i]);
+        result[i] = 0L;
+      }
+    return result;
+  }
+
+  public static float[] getFloatArray(String[] numbers) {
+    float[] result = new float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("float value expected but was: "+numbers[i]);
+        result[i] = 0.0f;
+      }
+    return result;
+  }
+
+  public static Float[] getFloatArrayWrap(String[] numbers) {
+    Float[] result = new Float[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Float.parseFloat(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Float value expected but was: "+numbers[i]);
+        result[i] = 0.0F;
+      }
+    return result;
+  }
+
+  public static double[] getDoubleArray(String[] numbers) {
+    double[] result = new double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("double value expected but was: "+numbers[i]);
+        result[i] = 0.0d;
+      }
+    return result;
+  }
+
+  public static Double[] getDoubleArrayWrap(String[] numbers) {
+    Double[] result = new Double[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = Double.parseDouble(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("Double value expected but was: "+numbers[i]);
+        result[i] = 0.0D;
+      }
+    return result;
+  }
+
+  public static BigInteger[] getBigIntegerArray(String[] numbers) {
+    BigInteger[] result = new BigInteger[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigInteger(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigInteger value expected but was: "+numbers[i]);
+        result[i] = new BigInteger("0");
+      }
+    return result;
+  }
+
+  public static BigDecimal[] getBigDecimalArray(String[] numbers) {
+    BigDecimal[] result = new BigDecimal[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try { result[i] = new BigDecimal(numbers[i]);
+      } catch (NumberFormatException nfe) {
+        System.out.println("BigDecimal value expected but was: "+numbers[i]);
+        result[i] = new BigDecimal("0.0");
+      }
+    return result;
+  }
+
+  public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) {
+    ZonedDateTime[] result = new ZonedDateTime[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = LocalDateTime
+                .parse(numbers[i],DateTimeFormatter.ofPattern(format))
+                .atZone(ZoneId.systemDefault())
+                .withZoneSameInstant(ZoneId.systemDefault());
+
+      } catch (DateTimeException dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = ZonedDateTime.now();
+      }
+    return result;
+  }
+
+  public static Date[] getDateArray(String[] numbers, String format) {
+    Date[] result = new Date[numbers.length];
+    for (int i = 0; i < numbers.length; i++)
+      try {
+        result[i] = new SimpleDateFormat(format).parse(numbers[i]);
+      } catch (Exception dte) {
+        System.out.println("Format["+format+"] expected but was: "+numbers[i]);
+        System.out.println("    "+dte.getMessage());
+        result[i] = new Date();
+      }
+    return result;
+  }
+}
\ No newline at end of file