docs: def validate_items(self):
          """ Validates the items in the backing array, including
          performing type validation.
  
          Sets the _typed property and clears the dirty flag as a side effect
  
          Returns:
              The typed array
          """
          logger.debug(fmt("Validating {}", self))
          from python_jsonschema_objects import classbuilder
  
          if self.__itemtype__ is None:
              return
  
          type_checks = self.__itemtype__
          if not isinstance(type_checks, (tuple, list)):
              # we were given items = {'type': 'blah'} ; thus ensure the type for all data.
              type_checks = [type_checks] * len(self.data)
          elif len(type_checks) > len(self.data):
              raise ValidationError(
                  "{1} does not have sufficient elements to validate against {0}"
                  .format(self.__itemtype__, self.data))
  
          typed_elems = []
          for elem, typ in zip(self.data, type_checks):
              if isinstance(typ, dict):
                  for param, paramval in six.iteritems(typ):
                      validator = registry(param)
                      if validator is not None:
                          validator(paramval, elem, typ)
                  typed_elems.append(elem)
  
              elif util.safe_issubclass(typ, classbuilder.LiteralValue):
                  val = typ(elem)
                  val.validate()
                  typed_elems.append(val)
              elif util.safe_issubclass(typ, classbuilder.ProtocolBase):
                  if not isinstance(elem, typ):
                      try:
                          if isinstance(elem, (six.string_types, six.integer_types, float)):
                              val = typ(elem)
                          else:
                              val = typ(**util.coerce_for_expansion(elem))
                      except TypeError as e:
                          raise ValidationError("'{0}' is not a valid value for '{1}': {2}"
                                                .format(elem, typ, e))
                  else:
                      val = elem
                  val.validate()
                  typed_elems.append(val)
  
              elif util.safe_issubclass(typ, ArrayWrapper):
                  val = typ(elem)
                  val.validate()
                  typed_elems.append(val)
  
              elif isinstance(typ, (classbuilder.TypeProxy, classbuilder.TypeRef)):
                  try:
                      if isinstance(elem, (six.string_types, six.integer_types, float)):
                          val = typ(elem)
                      else:
                          val = typ(**util.coerce_for_expansion(elem))
                  except TypeError as e:
                      raise ValidationError("'{0}' is not a valid value for '{1}': {2}"
                                            .format(elem, typ, e))
                  else:
                      val.validate()
                      typed_elems.append(val)
  
          self._dirty = False
          self._typed = typed_elems
          return typed_elems