code: def deserialize(self, payload, obj_type):
          # type: (str, Union[T, str]) -> Any
          
          if payload is None:
              return None
  
          try:
              payload = json.loads(payload)
          except Exception:
              raise SerializationException(
                  "Couldn't parse response body: {}".format(payload))
  
          return self.__deserialize(payload, obj_type)
docs: Deserializes payload into an instance of provided ``obj_type``.
  
          The ``obj_type`` parameter can be a primitive type, a generic
          model object or a list / dict of model objects.
  
          The list or dict object type has to be provided as a string
          format. For eg:
  
          * ``'list[a.b.C]'`` if the payload is a list of instances of
            class ``a.b.C``.
          * ``'dict(str, a.b.C)'`` if the payload is a dict containing
            mappings of ``str : a.b.C`` class instance types.
  
          The method looks for a ``deserialized_types`` dict in the model
          class, that mentions which payload values has to be
          deserialized. In case the payload key names are different than
          the model attribute names, the corresponding mapping can be
          provided in another special dict ``attribute_map``. The model
          class should also have the ``__init__`` method with default
          values for arguments. Check
          :py:class:`ask_sdk_model.request_envelope.RequestEnvelope`
          source code for an example implementation.
  
          :param payload: data to be deserialized.
          :type payload: str
          :param obj_type: resolved class name for deserialized object
          :type obj_type: Union[object, str]
          :return: deserialized object
          :rtype: object
          :raises: :py:class:`ask_sdk_core.exceptions.SerializationException`