code: def mark_typed_list(self, name, type_object):
          
  
          if not hasattr(type_object, 'dump'):
              raise ArgumentError("The passed type object %s is missing required method: dump()" % type_object)
          if not hasattr(type_object, 'Restore'):
              raise ArgumentError("The passed type object %s is missing required method: Restore()" % type_object)
  
          def _dump_list(obj):
              if obj is None:
                  return None
  
              if not isinstance(obj, list):
                  raise DataError("Property %s marked as list was not a list: %s" % (name, repr(obj)))
  
              return [x.dump() for x in obj]
  
          def _restore_list(obj):
              if obj is None:
                  return obj
  
              return [type_object.Restore(x) for x in obj]
  
          self.mark_complex(name, _dump_list, _restore_list)
docs: Mark a property as containing serializable objects of a given type.
  
          This convenience method allows you to avoid having to call
          ``mark_complex()`` whenever you need to serialize a list of objects.
          This method requires that all members of the given list be of a single
          class that contains a dump() method and a Restore() class method where
          type_object.Restore(x.dump()) == x.
  
          Args:
              name (str): The name of the complex property.
              type_object: The class object that will be contained inside
                  this list.