<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def method(self, returns, **parameter_types):
 """Syntactic sugar for registering a method Example: :param returns: The method's return type :type returns: type :param parameter_types: The types of the method's parameters :type parameter_types: dict[str, type] .. versionadded:: 0.1.0 """

        @wrapt.decorator
        def type_check_wrapper(method, instance, args, kwargs):
            """Wraps a method so that it is type-checked.

            :param method: The method to wrap
            :type method: (T) -> U
            :return: The result of calling the method with the given parameters
            :rtype: U
            """
            if instance is not None:
                raise Exception("Instance shouldn't be set.")

            parameter_names = inspect.getargspec(method).args  # pylint: disable=deprecated-method
            defaults = inspect.getargspec(method).defaults  # pylint: disable=deprecated-method
            parameters = self._collect_parameters(parameter_names, args, kwargs, defaults)

            parameter_checker.check_types(parameters, parameter_types, self._strict_floats)

            result = method(*args, **kwargs)
            parameter_checker.check_return_type(result, returns, self._strict_floats)

            return result

        def register_method(method):
            """Registers a method with its fully qualified name.

            :param method: The method to register
            :type method: function
            :return: The original method wrapped into a type-checker
            :rtype: function
            """
            parameter_names = inspect.getargspec(method).args  # pylint: disable=deprecated-method
            parameter_checker.check_type_declaration(parameter_names, parameter_types)

            wrapped_method = type_check_wrapper(method, None, None, None)
            fully_qualified_name = "{}.{}".format(method.__module__, method.__name__)
            self.register(fully_qualified_name, wrapped_method,
                          MethodSignature.create(parameter_names, parameter_types, returns))
            return wrapped_method

        return register_method