docs: def dump(self, obj, many=None):
          """Serialize an object to native Python data types according to this
          Schema's fields.
  
          :param obj: The object to serialize.
          :param bool many: Whether to serialize `obj` as a collection. If `None`, the value
              for `self.many` is used.
          :return: A dict of serialized data
          :rtype: dict
  
          .. versionadded:: 1.0.0
          .. versionchanged:: 3.0.0b7
              This method returns the serialized data rather than a ``(data, errors)`` duple.
              A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised
              if ``obj`` is invalid.
          """
          error_store = ErrorStore()
          errors = {}
          many = self.many if many is None else bool(many)
          if many and is_iterable_but_not_string(obj):
              obj = list(obj)
  
          if self._has_processors(PRE_DUMP):
              try:
                  processed_obj = self._invoke_dump_processors(
                      PRE_DUMP,
                      obj,
                      many,
                      original_data=obj,
                  )
              except ValidationError as error:
                  errors = error.normalized_messages()
                  result = None
          else:
              processed_obj = obj
  
          if not errors:
              result = self._serialize(
                  processed_obj,
                  self.fields,
                  error_store,
                  many=many,
                  accessor=self.get_attribute,
                  dict_class=self.dict_class,
                  index_errors=self.opts.index_errors,
              )
              errors = error_store.errors
  
          if not errors and self._has_processors(POST_DUMP):
              try:
                  result = self._invoke_dump_processors(
                      POST_DUMP,
                      result,
                      many,
                      original_data=obj,
                  )
              except ValidationError as error:
                  errors = error.normalized_messages()
          if errors:
              exc = ValidationError(
                  errors,
                  data=obj,
                  valid_data=result,
              )
              # User-defined error handler
              self.handle_error(exc, obj)
              raise exc
  
          return result