docs: def value_for_element(cls, elem):
          """Deserialize the given XML `Element` into its representative
          value.
  
          Depending on the content of the element, the returned value may be:
          * a string, integer, or boolean value
          * a `datetime.datetime` instance
          * a list of `Resource` instances
          * a single `Resource` instance
          * a `Money` instance
          * ``None``
  
          """
          log = logging.getLogger('recurly.resource')
          if elem is None:
              log.debug("Converting %r element into None value", elem)
              return
  
          if elem.attrib.get('nil') is not None:
              log.debug("Converting %r element with nil attribute into None value", elem.tag)
              return
  
          if elem.tag.endswith('_in_cents') and 'currency' not in cls.attributes and not cls.inherits_currency:
              log.debug("Converting %r element in class with no matching 'currency' into a Money value", elem.tag)
              return Money.from_element(elem)
  
          attr_type = elem.attrib.get('type')
          log.debug("Converting %r element with type %r", elem.tag, attr_type)
  
          if attr_type == 'integer':
              return int(elem.text.strip())
          if attr_type == 'float':
              return float(elem.text.strip())
          if attr_type == 'boolean':
              return elem.text.strip() == 'true'
          if attr_type == 'datetime':
              return iso8601.parse_date(elem.text.strip())
          if attr_type == 'array':
              return [cls._subclass_for_nodename(sub_elem.tag).from_element(sub_elem) for sub_elem in elem]
  
          # Unknown types may be the names of resource classes.
          if attr_type is not None:
              try:
                  value_class = cls._subclass_for_nodename(attr_type)
              except ValueError:
                  log.debug("Not converting %r element with type %r to a resource as that matches no known nodename",
                      elem.tag, attr_type)
              else:
                  return value_class.from_element(elem)
  
          # Untyped complex elements should still be resource instances. Guess from the nodename.
          if len(elem):  # has children
              value_class = cls._subclass_for_nodename(elem.tag)
              log.debug("Converting %r tag into a %s", elem.tag, value_class.__name__)
              return value_class.from_element(elem)
  
          value = elem.text or ''
          return value.strip()