def message(self,
                workspace_id,
                input=None,
                intents=None,
                entities=None,
                alternate_intents=None,
                context=None,
                output=None,
                nodes_visited_details=None,
                **kwargs):
        """
        Get response to user input.

        Send user input to a workspace and receive a response.
        There is no rate limit for this operation.

        :param str workspace_id: Unique identifier of the workspace.
        :param MessageInput input: An input object that includes the input text.
        :param list[RuntimeIntent] intents: Intents to use when evaluating the user input.
        Include intents from the previous response to continue using those intents rather
        than trying to recognize intents in the new input.
        :param list[RuntimeEntity] entities: Entities to use when evaluating the message.
        Include entities from the previous response to continue using those entities
        rather than detecting entities in the new input.
        :param bool alternate_intents: Whether to return more than one intent. A value of
        `true` indicates that all matching intents are returned.
        :param Context context: State information for the conversation. To maintain state,
        include the context from the previous response.
        :param OutputData output: An output object that includes the response to the user,
        the dialog nodes that were triggered, and messages from the log.
        :param bool nodes_visited_details: Whether to include additional diagnostic
        information about the dialog nodes that were visited during processing of the
        message.
        :param dict headers: A `dict` containing the request headers
        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
        :rtype: DetailedResponse
        """

        if workspace_id is None:
            raise ValueError('workspace_id must be provided')
        if input is not None:
            input = self._convert_model(input, MessageInput)
        if intents is not None:
            intents = [self._convert_model(x, RuntimeIntent) for x in intents]
        if entities is not None:
            entities = [self._convert_model(x, RuntimeEntity) for x in entities]
        if context is not None:
            context = self._convert_model(context, Context)
        if output is not None:
            output = self._convert_model(output, OutputData)

        headers = {}
        if 'headers' in kwargs:
            headers.update(kwargs.get('headers'))
        sdk_headers = get_sdk_headers('conversation', 'V1', 'message')
        headers.update(sdk_headers)

        params = {
            'version': self.version,
            'nodes_visited_details': nodes_visited_details
        }

        data = {
            'input': input,
            'intents': intents,
            'entities': entities,
            'alternate_intents': alternate_intents,
            'context': context,
            'output': output
        }

        url = '/v1/workspaces/{0}/message'.format(
            *self._encode_path_vars(workspace_id))
        response = self.request(
            method='POST',
            url=url,
            headers=headers,
            params=params,
            json=data,
            accept_json=True)
        return response