diff --git a/src/main/scala/util/Validations.scala b/src/main/scala/util/Validations.scala
index d5db5c9..8f70b5e 100644
--- a/src/main/scala/util/Validations.scala
+++ b/src/main/scala/util/Validations.scala
@@ -34,11 +34,11 @@
    */
   abstract class SingleValueType[T](constraints: Constraint*) extends ValueType[T]{
     
-    def convert(name: String, params: Map[String, String]): T = convert(params(name))
+    def convert(name: String, params: Map[String, String]): T = convert(params.get(name).orNull)
     
     def convert(value: String): T
     
-    def validate(name: String, params: Map[String, String]): Seq[(String, String)] = validate(name, params(name))
+    def validate(name: String, params: Map[String, String]): Seq[(String, String)] = validate(name, params.get(name).orNull)
     
     def validate(name: String, value: String): Seq[(String, String)] = validaterec(name, value, Seq(constraints: _*))
     
@@ -73,18 +73,218 @@
     }
   }
   
+  /**
+   * ValueType for the String property.
+   */
   def text(constraints: Constraint*): SingleValueType[String] = new SingleValueType[String](constraints: _*){
     def convert(value: String): String = value
   }
   
+  /**
+   * ValueType for the Boolean property.
+   */
+  def boolean(constraints: Constraint*): SingleValueType[Boolean] = new SingleValueType[Boolean](constraints: _*){
+    def convert(value: String): Boolean = value match {
+      case null|"false"|"FALSE" => false
+      case _ => true
+    }
+  }
+  
+  /**
+   * ValueType for the Int property.
+   */
+  def number(constraints: Constraint*): SingleValueType[Int] = new SingleValueType[Int](constraints: _*){
+    
+    def convert(value: String): Int = value match {
+      case null|"" => 0
+      case x => x.toInt
+    }
+    
+    override def validate(name: String, value: String): Seq[(String, String)] = {
+      try {
+        value.toInt
+        super.validate(name, value)
+      } catch {
+        case e: NumberFormatException => Seq(name -> "%s must be a number.".format(name))
+      }
+    }
+  }
+  
   def mapping[T, P1](f1: (String, ValueType[P1]))(factory: (P1) => T): MappingValueType[T] = new MappingValueType[T]{
     def fields = Seq(f1)
-    def convert(name: String, params: Map[String, String]) = factory(f1._2.convert(f1._1, params))
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params))
   }
   
   def mapping[T, P1, P2](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]))(factory: (P1, P2) => T): MappingValueType[T] = new MappingValueType[T]{
     def fields = Seq(f1, f2)
-    def convert(name: String, params: Map[String, String]) = factory(f1._2.convert(f1._1, params), f2._2.convert(f2._1, params))
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params))
+  }
+
+  def mapping[T, P1, P2, P3](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]))(factory: (P1, P2, P3) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]))(factory: (P1, P2, P3, P4) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]))(factory: (P1, P2, P3, P4, P5) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]))(factory: (P1, P2, P3, P4, P5, P6) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]))(factory: (P1, P2, P3, P4, P5, P6, P7) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]), f17: (String, ValueType[P17]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params), p(f17, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]), f17: (String, ValueType[P17]), f18: (String, ValueType[P18]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params), p(f17, params), p(f18, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]), f17: (String, ValueType[P17]), f18: (String, ValueType[P18]), f19: (String, ValueType[P19]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params), p(f17, params), p(f18, params), p(f19, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]), f17: (String, ValueType[P17]), f18: (String, ValueType[P18]), f19: (String, ValueType[P19]), f20: (String, ValueType[P20]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params), p(f17, params), p(f18, params), p(f19, params), p(f20, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]), f17: (String, ValueType[P17]), f18: (String, ValueType[P18]), f19: (String, ValueType[P19]), f20: (String, ValueType[P20]), f21: (String, ValueType[P21]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params), p(f17, params), p(f18, params), p(f19, params), p(f20, params), p(f21, params))
+  }
+  
+  def mapping[T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22](f1: (String, ValueType[P1]), f2: (String, ValueType[P2]), f3: (String, ValueType[P3]), f4: (String, ValueType[P4]), f5: (String, ValueType[P5]), f6: (String, ValueType[P6]), f7: (String, ValueType[P7]), f8: (String, ValueType[P8]), f9: (String, ValueType[P9]), f10: (String, ValueType[P10]), f11: (String, ValueType[P11]), f12: (String, ValueType[P12]), f13: (String, ValueType[P13]), f14: (String, ValueType[P14]), f15: (String, ValueType[P15]), f16: (String, ValueType[P16]), f17: (String, ValueType[P17]), f18: (String, ValueType[P18]), f19: (String, ValueType[P19]), f20: (String, ValueType[P20]), f21: (String, ValueType[P21]), f22: (String, ValueType[P22]))(factory: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22) => T): MappingValueType[T] = new MappingValueType[T]{
+    def fields = Seq(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22)
+    def convert(name: String, params: Map[String, String]) = factory(p(f1, params), p(f2, params), p(f3, params), p(f4, params), p(f5, params), p(f6, params), p(f7, params), p(f8, params), p(f9, params), p(f10, params), p(f11, params), p(f12, params), p(f13, params), p(f14, params), p(f15, params), p(f16, params), p(f17, params), p(f18, params), p(f19, params), p(f20, params), p(f21, params), p(f22, params))
+  }
+  
+  private def p[T](field: (String, ValueType[T]), params: Map[String, String]): T = field._2.convert(field._1, params)
+  
+  /////////////////////////////////////////////////////////////////////////////////////////////
+  // ValueType wrappers to provide additional features.
+  
+  /**
+   * ValueType wrapper for the Option property.
+   */
+  def optional[T](valueType: SingleValueType[T]): SingleValueType[Option[T]] = new SingleValueType[Option[T]](){
+    def convert(value: String): Option[T] = if(value == null) None else Some(valueType.convert(value))
+    override def validate(name: String, value: String): Seq[(String, String)] = if(value == null) Nil else valueType.validate(name, value)
+  }
+  
+  /**
+   * ValueType wrapper to trim a parameter.
+   * 
+   * {{{
+   * val form = mapping(
+   *   "name" -> trim(text(required)),
+   *   "mail" -> trim(text(required))
+   * )
+   * }}}
+   */
+  def trim[T](valueType: SingleValueType[T]): SingleValueType[T] = new SingleValueType[T](){
+    def convert(value: String): T = valueType.convert(value.trim)
+    override def validate(name: String, value: String): Seq[(String, String)] = valueType.validate(name, value.trim)
+  }
+  
+  /**
+   * ValueType wrapper to trim all parameters.
+   * 
+   * {{{
+   * val form = trim(mapping(
+   *   "name" -> text(required),
+   *   "mail" -> text(required)
+   * ))
+   * }}}
+   */
+  def trim[T](valueType: MappingValueType[T]): MappingValueType[T] = new MappingValueType[T](){
+    def validate(name: String, params: Map[String, String]): Seq[(String, String)] =
+      fields.map { case (name, valueType) => valueType.validate(name, trimMap(params)) }.flatten
+    
+    def validateAsJSON(params: Map[String, String]): JObject = {
+      JObject(validate("form", trimMap(params)).map { case (key, value) =>
+        JField(key, JString(value))
+      }.toList)
+    }
+      
+    private def trimMap(params: Map[String, String]): Map[String, String] = params.map{ x => x._1 -> x._2.trim }
+  }
+  
+  /**
+   * ValueType wrapper to specified a property name which is used in the error message. 
+   * 
+   * {{{
+   * val form = trim(mapping(
+   *   "name" -> label("User name"   , text(required)),
+   *   "mail" -> label("Mail address", text(required))
+   * ))
+   * }}}
+    */
+  def label[T](label: String, valueType: SingleValueType[T]): SingleValueType[T] = new SingleValueType[T](){
+    def convert(value: String): T = valueType.convert(value)
+    override def validate(name: String, value: String): Seq[(String, String)] = 
+      valueType.validate(label, value).map { case (label, message) => name -> message }
   }
   
   /////////////////////////////////////////////////////////////////////////////////////////////
@@ -96,47 +296,30 @@
   
   def required: Constraint = new Constraint(){
     def validate(name: String, value: String): Option[String] = {
-      if(value.isEmpty) Some("%s is required.".format(name)) else None
+      if(value == null || value.isEmpty) Some("%s is required.".format(name)) else None
     }
   }
   
   def required(message: String): Constraint = new Constraint(){
     def validate(name: String, value: String): Option[String] = 
-      if(value.isEmpty) Some(message) else None
+      if(value == null || value.isEmpty) Some(message) else None
   }
   
   def maxlength(length: Int): Constraint = new Constraint(){
     def validate(name: String, value: String): Option[String] =
-      if(value.length > length) Some("%s cannot be longer than %d characters.".format(name, length)) else None
+      if(value != null && value.length > length) Some("%s cannot be longer than %d characters.".format(name, length)) else None
   }
   
   def minlength(length: Int): Constraint = new Constraint(){
     def validate(name: String, value: String): Option[String] =
-      if(value.length < length) Some("%s cannot be shorter than %d characters".format(name, length)) else None
+      if(value != null && value.length < length) Some("%s cannot be shorter than %d characters".format(name, length)) else None
   }
   
   def pattern(pattern: String, message: String = ""): Constraint = new Constraint {
     def validate(name: String, value: String): Option[String] =
-      if(!value.matches("^" + pattern + "$")){
+      if(value != null && !value.matches("^" + pattern + "$")){
         if(message.isEmpty) Some("%s must be '%s'.".format(name, pattern)) else Some(message)
       } else None
   }
   
-  // TODO make basic Constraints for Int, Long, Boolean and Option
-  
-  /////////////////////////////////////////////////////////////////////////////////////////////
-  // ValueType wrappers to provide additional features.
-  
-  // TODO make an other trim implementation for MappingValueType which is trim all parameters.
-  def trim[T](valueType: SingleValueType[T]): SingleValueType[T] = new SingleValueType[T](){
-    def convert(value: String): T = valueType.convert(value.trim)
-    override def validate(name: String, value: String): Seq[(String, String)] = valueType.validate(name, value.trim)
-  }
-  
-  def label[T](label: String, valueType: SingleValueType[T]): SingleValueType[T] = new SingleValueType[T](){
-    def convert(value: String): T = valueType.convert(value)
-    override def validate(name: String, value: String): Seq[(String, String)] = 
-      valueType.validate(label, value).map { case (label, message) => name -> message }
-  }
-  
 }
\ No newline at end of file