docs: def CallState(self,
                  messages=None,
                  next_state="",
                  client_id=None,
                  request_data=None,
                  start_time=None):
      """This method is used to asynchronously schedule a new hunt state.
  
      The state will be invoked in a later time and receive all the messages
      we send.
  
      Args:
        messages: A list of rdfvalues to send. If the last one is not a GrrStatus,
          we append an OK Status.
        next_state: The state in this hunt to be invoked with the responses.
        client_id: ClientURN to use in scheduled requests.
        request_data: Any dict provided here will be available in the RequestState
          protobuf. The Responses object maintains a reference to this protobuf
          for use in the execution of the state method. (so you can access this
          data by responses.request).
        start_time: Schedule the state at this time. This delays notification and
          messages for processing into the future.
  
      Raises:
        ValueError: on arguments error.
      """
  
      if messages is None:
        messages = []
  
      if not next_state:
        raise ValueError("next_state can't be empty.")
  
      # Now we construct a special response which will be sent to the hunt
      # flow. Randomize the request_id so we do not overwrite other messages in
      # the queue.
      request_state = rdf_flow_runner.RequestState(
          id=random.UInt32(),
          session_id=self.context.session_id,
          client_id=client_id,
          next_state=next_state)
  
      if request_data:
        request_state.data = rdf_protodict.Dict().FromDict(request_data)
  
      self.QueueRequest(request_state, timestamp=start_time)
  
      # Add the status message if needed.
      if not messages or not isinstance(messages[-1], rdf_flows.GrrStatus):
        messages.append(rdf_flows.GrrStatus())
  
      # Send all the messages
      for i, payload in enumerate(messages):
        if isinstance(payload, rdfvalue.RDFValue):
          msg = rdf_flows.GrrMessage(
              session_id=self.session_id,
              request_id=request_state.id,
              response_id=1 + i,
              auth_state=rdf_flows.GrrMessage.AuthorizationState.AUTHENTICATED,
              payload=payload,
              type=rdf_flows.GrrMessage.Type.MESSAGE)
  
          if isinstance(payload, rdf_flows.GrrStatus):
            msg.type = rdf_flows.GrrMessage.Type.STATUS
        else:
          raise flow_runner.FlowRunnerError("Bad message %s of type %s." %
                                            (payload, type(payload)))
  
        self.QueueResponse(msg, timestamp=start_time)
  
      # Notify the worker about it.
      self.QueueNotification(session_id=self.session_id, timestamp=start_time)