require "uri"

module PureCloud
  class ConversationsApi
    attr_accessor :api_client

    def initialize(api_client = ApiClient.default)
      @api_client = api_client
    end

    # Query for conversation aggregates
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [AggregationQuery] :body query
    # @return [AggregateQueryResponse]
    def post_conversations_aggregates_query(opts = {})
      data, status_code, headers = post_conversations_aggregates_query_with_http_info(opts)
      return data
    end

    # Query for conversation aggregates
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [AggregationQuery] :body query
    # @return [Array<(AggregateQueryResponse, Fixnum, Hash)>] AggregateQueryResponse data, response status code and response headers
    def post_conversations_aggregates_query_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_conversations_aggregates_query ..."
      end
      
      # resource path
      path = "/api/v2/analytics/conversations/aggregates/query".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'AggregateQueryResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_conversations_aggregates_query\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Query for conversation details
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [ConversationQuery] :body query
    # @return [AnalyticsConversationQueryResponse]
    def post_conversations_details_query(opts = {})
      data, status_code, headers = post_conversations_details_query_with_http_info(opts)
      return data
    end

    # Query for conversation details
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [ConversationQuery] :body query
    # @return [Array<(AnalyticsConversationQueryResponse, Fixnum, Hash)>] AnalyticsConversationQueryResponse data, response status code and response headers
    def post_conversations_details_query_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_conversations_details_query ..."
      end
      
      # resource path
      path = "/api/v2/analytics/conversations/details/query".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'AnalyticsConversationQueryResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_conversations_details_query\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a conversation by id
    # 
    # @param conversation_id conversationId
    # @param [Hash] opts the optional parameters
    # @return [AnalyticsConversation]
    def get_conversations_conversation_id_details(conversation_id, opts = {})
      data, status_code, headers = get_conversations_conversation_id_details_with_http_info(conversation_id, opts)
      return data
    end

    # Get a conversation by id
    # 
    # @param conversation_id conversationId
    # @param [Hash] opts the optional parameters
    # @return [Array<(AnalyticsConversation, Fixnum, Hash)>] AnalyticsConversation data, response status code and response headers
    def get_conversations_conversation_id_details_with_http_info(conversation_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_conversations_conversation_id_details ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling get_conversations_conversation_id_details" if conversation_id.nil?
      
      # resource path
      path = "/api/v2/analytics/conversations/{conversationId}/details".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'AnalyticsConversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_conversations_conversation_id_details\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Index conversation properties
    # 
    # @param conversation_id conversationId
    # @param [Hash] opts the optional parameters
    # @option opts [PropertyIndexRequest] :body request
    # @return [PropertyIndexRequest]
    def post_conversations_conversation_id_details_properties(conversation_id, opts = {})
      data, status_code, headers = post_conversations_conversation_id_details_properties_with_http_info(conversation_id, opts)
      return data
    end

    # Index conversation properties
    # 
    # @param conversation_id conversationId
    # @param [Hash] opts the optional parameters
    # @option opts [PropertyIndexRequest] :body request
    # @return [Array<(PropertyIndexRequest, Fixnum, Hash)>] PropertyIndexRequest data, response status code and response headers
    def post_conversations_conversation_id_details_properties_with_http_info(conversation_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_conversations_conversation_id_details_properties ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling post_conversations_conversation_id_details_properties" if conversation_id.nil?
      
      # resource path
      path = "/api/v2/analytics/conversations/{conversationId}/details/properties".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'PropertyIndexRequest')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_conversations_conversation_id_details_properties\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get conversations
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [String] :communication_type Call or Chat communication filtering
    # @return [ConversationEntityListing]
    def get_conversations(opts = {})
      data, status_code, headers = get_conversations_with_http_info(opts)
      return data
    end

    # Get conversations
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [String] :communication_type Call or Chat communication filtering
    # @return [Array<(ConversationEntityListing, Fixnum, Hash)>] ConversationEntityListing data, response status code and response headers
    def get_conversations_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_conversations ..."
      end
      
      # resource path
      path = "/api/v2/conversations".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'communicationType'] = opts[:'communication_type'] if opts[:'communication_type']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ConversationEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_conversations\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get callback conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [CallbackConversationEntityListing]
    def get_callbacks(opts = {})
      data, status_code, headers = get_callbacks_with_http_info(opts)
      return data
    end

    # Get callback conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(CallbackConversationEntityListing, Fixnum, Hash)>] CallbackConversationEntityListing data, response status code and response headers
    def get_callbacks_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_callbacks ..."
      end
      
      # resource path
      path = "/api/v2/conversations/callbacks".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'CallbackConversationEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_callbacks\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get callback conversation
    # 
    # @param callback_id 
    # @param [Hash] opts the optional parameters
    # @return [CallbackConversation]
    def get_callbacks_callback_id(callback_id, opts = {})
      data, status_code, headers = get_callbacks_callback_id_with_http_info(callback_id, opts)
      return data
    end

    # Get callback conversation
    # 
    # @param callback_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(CallbackConversation, Fixnum, Hash)>] CallbackConversation data, response status code and response headers
    def get_callbacks_callback_id_with_http_info(callback_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_callbacks_callback_id ..."
      end
      
      # verify the required parameter 'callback_id' is set
      fail "Missing the required parameter 'callback_id' when calling get_callbacks_callback_id" if callback_id.nil?
      
      # resource path
      path = "/api/v2/conversations/callbacks/{callbackId}".sub('{format}','json').sub('{' + 'callbackId' + '}', callback_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'CallbackConversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_callbacks_callback_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update conversation participant
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [nil]
    def patch_callbacks_callback_id_participants_participant_id(callback_id, participant_id, opts = {})
      patch_callbacks_callback_id_participants_participant_id_with_http_info(callback_id, participant_id, opts)
      return nil
    end

    # Update conversation participant
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_callbacks_callback_id_participants_participant_id_with_http_info(callback_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_callbacks_callback_id_participants_participant_id ..."
      end
      
      # verify the required parameter 'callback_id' is set
      fail "Missing the required parameter 'callback_id' when calling patch_callbacks_callback_id_participants_participant_id" if callback_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_callbacks_callback_id_participants_participant_id" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/callbacks/{callbackId}/participants/{participantId}".sub('{format}','json').sub('{' + 'callbackId' + '}', callback_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_callbacks_callback_id_participants_participant_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the attributes on a conversation participant.
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [nil]
    def patch_callbacks_callback_id_participants_participant_id_attributes(callback_id, participant_id, opts = {})
      patch_callbacks_callback_id_participants_participant_id_attributes_with_http_info(callback_id, participant_id, opts)
      return nil
    end

    # Update the attributes on a conversation participant.
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_callbacks_callback_id_participants_participant_id_attributes_with_http_info(callback_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_callbacks_callback_id_participants_participant_id_attributes ..."
      end
      
      # verify the required parameter 'callback_id' is set
      fail "Missing the required parameter 'callback_id' when calling patch_callbacks_callback_id_participants_participant_id_attributes" if callback_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_callbacks_callback_id_participants_participant_id_attributes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/callbacks/{callbackId}/participants/{participantId}/attributes".sub('{format}','json').sub('{' + 'callbackId' + '}', callback_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_callbacks_callback_id_participants_participant_id_attributes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [nil]
    def post_callbacks_callback_id_participants_participant_id_replace(callback_id, participant_id, opts = {})
      post_callbacks_callback_id_participants_participant_id_replace_with_http_info(callback_id, participant_id, opts)
      return nil
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_callbacks_callback_id_participants_participant_id_replace_with_http_info(callback_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_callbacks_callback_id_participants_participant_id_replace ..."
      end
      
      # verify the required parameter 'callback_id' is set
      fail "Missing the required parameter 'callback_id' when calling post_callbacks_callback_id_participants_participant_id_replace" if callback_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_callbacks_callback_id_participants_participant_id_replace" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/callbacks/{callbackId}/participants/{participantId}/replace".sub('{format}','json').sub('{' + 'callbackId' + '}', callback_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_callbacks_callback_id_participants_participant_id_replace\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [WrapupCode]
    def get_callbacks_callback_id_participants_participant_id_wrapup(callback_id, participant_id, opts = {})
      data, status_code, headers = get_callbacks_callback_id_participants_participant_id_wrapup_with_http_info(callback_id, participant_id, opts)
      return data
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_callbacks_callback_id_participants_participant_id_wrapup_with_http_info(callback_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_callbacks_callback_id_participants_participant_id_wrapup ..."
      end
      
      # verify the required parameter 'callback_id' is set
      fail "Missing the required parameter 'callback_id' when calling get_callbacks_callback_id_participants_participant_id_wrapup" if callback_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_callbacks_callback_id_participants_participant_id_wrapup" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/callbacks/{callbackId}/participants/{participantId}/wrapup".sub('{format}','json').sub('{' + 'callbackId' + '}', callback_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'provisional'] = opts[:'provisional'] if opts[:'provisional']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_callbacks_callback_id_participants_participant_id_wrapup\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [WrapupCode]
    def get_callbacks_callback_id_participants_participant_id_wrapupcodes(callback_id, participant_id, opts = {})
      data, status_code, headers = get_callbacks_callback_id_participants_participant_id_wrapupcodes_with_http_info(callback_id, participant_id, opts)
      return data
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param callback_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_callbacks_callback_id_participants_participant_id_wrapupcodes_with_http_info(callback_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_callbacks_callback_id_participants_participant_id_wrapupcodes ..."
      end
      
      # verify the required parameter 'callback_id' is set
      fail "Missing the required parameter 'callback_id' when calling get_callbacks_callback_id_participants_participant_id_wrapupcodes" if callback_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_callbacks_callback_id_participants_participant_id_wrapupcodes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/callbacks/{callbackId}/participants/{participantId}/wrapupcodes".sub('{format}','json').sub('{' + 'callbackId' + '}', callback_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_callbacks_callback_id_participants_participant_id_wrapupcodes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get recent conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [CallConversationEntityListing]
    def get_calls(opts = {})
      data, status_code, headers = get_calls_with_http_info(opts)
      return data
    end

    # Get recent conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(CallConversationEntityListing, Fixnum, Hash)>] CallConversationEntityListing data, response status code and response headers
    def get_calls_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_calls ..."
      end
      
      # resource path
      path = "/api/v2/conversations/calls".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'CallConversationEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_calls\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a call conversation
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [CreateCallRequest] :body 
    # @return [CreateCallResponse]
    def post_calls(opts = {})
      data, status_code, headers = post_calls_with_http_info(opts)
      return data
    end

    # Create a call conversation
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [CreateCallRequest] :body 
    # @return [Array<(CreateCallResponse, Fixnum, Hash)>] CreateCallResponse data, response status code and response headers
    def post_calls_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_calls ..."
      end
      
      # resource path
      path = "/api/v2/conversations/calls".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'CreateCallResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_calls\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the maximum number of participants that this user can have on a conference
    # 
    # @param [Hash] opts the optional parameters
    # @return [MaxParticipants]
    def get_calls_maximumconferenceparties(opts = {})
      data, status_code, headers = get_calls_maximumconferenceparties_with_http_info(opts)
      return data
    end

    # Get the maximum number of participants that this user can have on a conference
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(MaxParticipants, Fixnum, Hash)>] MaxParticipants data, response status code and response headers
    def get_calls_maximumconferenceparties_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_calls_maximumconferenceparties ..."
      end
      
      # resource path
      path = "/api/v2/conversations/calls/maximumconferenceparties".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'MaxParticipants')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_calls_maximumconferenceparties\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get call conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @return [CallConversation]
    def get_calls_call_id(call_id, opts = {})
      data, status_code, headers = get_calls_call_id_with_http_info(call_id, opts)
      return data
    end

    # Get call conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(CallConversation, Fixnum, Hash)>] CallConversation data, response status code and response headers
    def get_calls_call_id_with_http_info(call_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_calls_call_id ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling get_calls_call_id" if call_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'CallConversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_calls_call_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Add a new call to a conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @option opts [CallCommand] :body Conversation
    # @return [Conversation]
    def post_calls_call_id(call_id, opts = {})
      data, status_code, headers = post_calls_call_id_with_http_info(call_id, opts)
      return data
    end

    # Add a new call to a conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @option opts [CallCommand] :body Conversation
    # @return [Array<(Conversation, Fixnum, Hash)>] Conversation data, response status code and response headers
    def post_calls_call_id_with_http_info(call_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_calls_call_id ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling post_calls_call_id" if call_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Conversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_calls_call_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @option opts [Conversation] :body Conversation
    # @return [Conversation]
    def patch_calls_call_id(call_id, opts = {})
      data, status_code, headers = patch_calls_call_id_with_http_info(call_id, opts)
      return data
    end

    # Update conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @option opts [Conversation] :body Conversation
    # @return [Array<(Conversation, Fixnum, Hash)>] Conversation data, response status code and response headers
    def patch_calls_call_id_with_http_info(call_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_calls_call_id ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling patch_calls_call_id" if call_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Conversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_calls_call_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Add participants to a conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @option opts [Conversation] :body Conversation
    # @return [Conversation]
    def post_calls_call_id_participants(call_id, opts = {})
      data, status_code, headers = post_calls_call_id_participants_with_http_info(call_id, opts)
      return data
    end

    # Add participants to a conversation
    # 
    # @param call_id 
    # @param [Hash] opts the optional parameters
    # @option opts [Conversation] :body Conversation
    # @return [Array<(Conversation, Fixnum, Hash)>] Conversation data, response status code and response headers
    def post_calls_call_id_participants_with_http_info(call_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_calls_call_id_participants ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling post_calls_call_id_participants" if call_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Conversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_calls_call_id_participants\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update conversation participant
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [nil]
    def patch_calls_call_id_participants_participant_id(call_id, participant_id, opts = {})
      patch_calls_call_id_participants_participant_id_with_http_info(call_id, participant_id, opts)
      return nil
    end

    # Update conversation participant
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_calls_call_id_participants_participant_id_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_calls_call_id_participants_participant_id ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling patch_calls_call_id_participants_participant_id" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_calls_call_id_participants_participant_id" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_calls_call_id_participants_participant_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the attributes on a conversation participant.
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [nil]
    def patch_calls_call_id_participants_participant_id_attributes(call_id, participant_id, opts = {})
      patch_calls_call_id_participants_participant_id_attributes_with_http_info(call_id, participant_id, opts)
      return nil
    end

    # Update the attributes on a conversation participant.
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_calls_call_id_participants_participant_id_attributes_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_calls_call_id_participants_participant_id_attributes ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling patch_calls_call_id_participants_participant_id_attributes" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_calls_call_id_participants_participant_id_attributes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/attributes".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_calls_call_id_participants_participant_id_attributes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Initiate and update consult transfer
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ConsultTransfer] :body Destination address &amp; initial speak to
    # @return [ConsultTransferResponse]
    def post_calls_call_id_participants_participant_id_consult(call_id, participant_id, opts = {})
      data, status_code, headers = post_calls_call_id_participants_participant_id_consult_with_http_info(call_id, participant_id, opts)
      return data
    end

    # Initiate and update consult transfer
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ConsultTransfer] :body Destination address &amp; initial speak to
    # @return [Array<(ConsultTransferResponse, Fixnum, Hash)>] ConsultTransferResponse data, response status code and response headers
    def post_calls_call_id_participants_participant_id_consult_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_calls_call_id_participants_participant_id_consult ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling post_calls_call_id_participants_participant_id_consult" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_calls_call_id_participants_participant_id_consult" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/consult".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ConsultTransferResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_calls_call_id_participants_participant_id_consult\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Cancel the transfer
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_calls_call_id_participants_participant_id_consult(call_id, participant_id, opts = {})
      data, status_code, headers = delete_calls_call_id_participants_participant_id_consult_with_http_info(call_id, participant_id, opts)
      return data
    end

    # Cancel the transfer
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_calls_call_id_participants_participant_id_consult_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#delete_calls_call_id_participants_participant_id_consult ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling delete_calls_call_id_participants_participant_id_consult" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling delete_calls_call_id_participants_participant_id_consult" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/consult".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#delete_calls_call_id_participants_participant_id_consult\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Change who can speak
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ConsultTransferUpdate] :body new speak to
    # @return [ConsultTransferResponse]
    def patch_calls_call_id_participants_participant_id_consult(call_id, participant_id, opts = {})
      data, status_code, headers = patch_calls_call_id_participants_participant_id_consult_with_http_info(call_id, participant_id, opts)
      return data
    end

    # Change who can speak
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ConsultTransferUpdate] :body new speak to
    # @return [Array<(ConsultTransferResponse, Fixnum, Hash)>] ConsultTransferResponse data, response status code and response headers
    def patch_calls_call_id_participants_participant_id_consult_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_calls_call_id_participants_participant_id_consult ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling patch_calls_call_id_participants_participant_id_consult" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_calls_call_id_participants_participant_id_consult" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/consult".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ConsultTransferResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_calls_call_id_participants_participant_id_consult\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Listen in on the conversation from the point of view of a given participant.
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def post_calls_call_id_participants_participant_id_monitor(call_id, participant_id, opts = {})
      post_calls_call_id_participants_participant_id_monitor_with_http_info(call_id, participant_id, opts)
      return nil
    end

    # Listen in on the conversation from the point of view of a given participant.
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_calls_call_id_participants_participant_id_monitor_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_calls_call_id_participants_participant_id_monitor ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling post_calls_call_id_participants_participant_id_monitor" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_calls_call_id_participants_participant_id_monitor" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/monitor".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_calls_call_id_participants_participant_id_monitor\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [nil]
    def post_calls_call_id_participants_participant_id_replace(call_id, participant_id, opts = {})
      post_calls_call_id_participants_participant_id_replace_with_http_info(call_id, participant_id, opts)
      return nil
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_calls_call_id_participants_participant_id_replace_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_calls_call_id_participants_participant_id_replace ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling post_calls_call_id_participants_participant_id_replace" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_calls_call_id_participants_participant_id_replace" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/replace".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_calls_call_id_participants_participant_id_replace\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [WrapupCode]
    def get_calls_call_id_participants_participant_id_wrapup(call_id, participant_id, opts = {})
      data, status_code, headers = get_calls_call_id_participants_participant_id_wrapup_with_http_info(call_id, participant_id, opts)
      return data
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_calls_call_id_participants_participant_id_wrapup_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_calls_call_id_participants_participant_id_wrapup ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling get_calls_call_id_participants_participant_id_wrapup" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_calls_call_id_participants_participant_id_wrapup" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/wrapup".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'provisional'] = opts[:'provisional'] if opts[:'provisional']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_calls_call_id_participants_participant_id_wrapup\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [WrapupCode]
    def get_calls_call_id_participants_participant_id_wrapupcodes(call_id, participant_id, opts = {})
      data, status_code, headers = get_calls_call_id_participants_participant_id_wrapupcodes_with_http_info(call_id, participant_id, opts)
      return data
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param call_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_calls_call_id_participants_participant_id_wrapupcodes_with_http_info(call_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_calls_call_id_participants_participant_id_wrapupcodes ..."
      end
      
      # verify the required parameter 'call_id' is set
      fail "Missing the required parameter 'call_id' when calling get_calls_call_id_participants_participant_id_wrapupcodes" if call_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_calls_call_id_participants_participant_id_wrapupcodes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/calls/{callId}/participants/{participantId}/wrapupcodes".sub('{format}','json').sub('{' + 'callId' + '}', call_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_calls_call_id_participants_participant_id_wrapupcodes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get recent chat conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [ChatConversationEntityListing]
    def get_chats(opts = {})
      data, status_code, headers = get_chats_with_http_info(opts)
      return data
    end

    # Get recent chat conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ChatConversationEntityListing, Fixnum, Hash)>] ChatConversationEntityListing data, response status code and response headers
    def get_chats_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_chats ..."
      end
      
      # resource path
      path = "/api/v2/conversations/chats".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ChatConversationEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_chats\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get chat conversation
    # 
    # @param chat_id 
    # @param [Hash] opts the optional parameters
    # @return [ChatConversation]
    def get_chats_chat_id(chat_id, opts = {})
      data, status_code, headers = get_chats_chat_id_with_http_info(chat_id, opts)
      return data
    end

    # Get chat conversation
    # 
    # @param chat_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ChatConversation, Fixnum, Hash)>] ChatConversation data, response status code and response headers
    def get_chats_chat_id_with_http_info(chat_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_chats_chat_id ..."
      end
      
      # verify the required parameter 'chat_id' is set
      fail "Missing the required parameter 'chat_id' when calling get_chats_chat_id" if chat_id.nil?
      
      # resource path
      path = "/api/v2/conversations/chats/{chatId}".sub('{format}','json').sub('{' + 'chatId' + '}', chat_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ChatConversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_chats_chat_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update conversation participant
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [nil]
    def patch_chats_chat_id_participants_participant_id(chat_id, participant_id, opts = {})
      patch_chats_chat_id_participants_participant_id_with_http_info(chat_id, participant_id, opts)
      return nil
    end

    # Update conversation participant
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_chats_chat_id_participants_participant_id_with_http_info(chat_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_chats_chat_id_participants_participant_id ..."
      end
      
      # verify the required parameter 'chat_id' is set
      fail "Missing the required parameter 'chat_id' when calling patch_chats_chat_id_participants_participant_id" if chat_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_chats_chat_id_participants_participant_id" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/chats/{chatId}/participants/{participantId}".sub('{format}','json').sub('{' + 'chatId' + '}', chat_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_chats_chat_id_participants_participant_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the attributes on a conversation participant.
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [nil]
    def patch_chats_chat_id_participants_participant_id_attributes(chat_id, participant_id, opts = {})
      patch_chats_chat_id_participants_participant_id_attributes_with_http_info(chat_id, participant_id, opts)
      return nil
    end

    # Update the attributes on a conversation participant.
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_chats_chat_id_participants_participant_id_attributes_with_http_info(chat_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_chats_chat_id_participants_participant_id_attributes ..."
      end
      
      # verify the required parameter 'chat_id' is set
      fail "Missing the required parameter 'chat_id' when calling patch_chats_chat_id_participants_participant_id_attributes" if chat_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_chats_chat_id_participants_participant_id_attributes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/chats/{chatId}/participants/{participantId}/attributes".sub('{format}','json').sub('{' + 'chatId' + '}', chat_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_chats_chat_id_participants_participant_id_attributes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [nil]
    def post_chats_chat_id_participants_participant_id_replace(chat_id, participant_id, opts = {})
      post_chats_chat_id_participants_participant_id_replace_with_http_info(chat_id, participant_id, opts)
      return nil
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_chats_chat_id_participants_participant_id_replace_with_http_info(chat_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_chats_chat_id_participants_participant_id_replace ..."
      end
      
      # verify the required parameter 'chat_id' is set
      fail "Missing the required parameter 'chat_id' when calling post_chats_chat_id_participants_participant_id_replace" if chat_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_chats_chat_id_participants_participant_id_replace" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/chats/{chatId}/participants/{participantId}/replace".sub('{format}','json').sub('{' + 'chatId' + '}', chat_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_chats_chat_id_participants_participant_id_replace\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [WrapupCode]
    def get_chats_chat_id_participants_participant_id_wrapup(chat_id, participant_id, opts = {})
      data, status_code, headers = get_chats_chat_id_participants_participant_id_wrapup_with_http_info(chat_id, participant_id, opts)
      return data
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_chats_chat_id_participants_participant_id_wrapup_with_http_info(chat_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_chats_chat_id_participants_participant_id_wrapup ..."
      end
      
      # verify the required parameter 'chat_id' is set
      fail "Missing the required parameter 'chat_id' when calling get_chats_chat_id_participants_participant_id_wrapup" if chat_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_chats_chat_id_participants_participant_id_wrapup" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/chats/{chatId}/participants/{participantId}/wrapup".sub('{format}','json').sub('{' + 'chatId' + '}', chat_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'provisional'] = opts[:'provisional'] if opts[:'provisional']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_chats_chat_id_participants_participant_id_wrapup\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [WrapupCode]
    def get_chats_chat_id_participants_participant_id_wrapupcodes(chat_id, participant_id, opts = {})
      data, status_code, headers = get_chats_chat_id_participants_participant_id_wrapupcodes_with_http_info(chat_id, participant_id, opts)
      return data
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param chat_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_chats_chat_id_participants_participant_id_wrapupcodes_with_http_info(chat_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_chats_chat_id_participants_participant_id_wrapupcodes ..."
      end
      
      # verify the required parameter 'chat_id' is set
      fail "Missing the required parameter 'chat_id' when calling get_chats_chat_id_participants_participant_id_wrapupcodes" if chat_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_chats_chat_id_participants_participant_id_wrapupcodes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/chats/{chatId}/participants/{participantId}/wrapupcodes".sub('{format}','json').sub('{' + 'chatId' + '}', chat_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_chats_chat_id_participants_participant_id_wrapupcodes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get recent email conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [EmailConversationEntityListing]
    def get_emails(opts = {})
      data, status_code, headers = get_emails_with_http_info(opts)
      return data
    end

    # Get recent email conversations
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmailConversationEntityListing, Fixnum, Hash)>] EmailConversationEntityListing data, response status code and response headers
    def get_emails_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails ..."
      end
      
      # resource path
      path = "/api/v2/conversations/emails".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailConversationEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get email conversation
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @return [EmailConversation]
    def get_emails_email_id(email_id, opts = {})
      data, status_code, headers = get_emails_email_id_with_http_info(email_id, opts)
      return data
    end

    # Get email conversation
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmailConversation, Fixnum, Hash)>] EmailConversation data, response status code and response headers
    def get_emails_email_id_with_http_info(email_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails_email_id ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling get_emails_email_id" if email_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailConversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails_email_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get conversation messages
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @return [EmailMessageListing]
    def get_emails_email_id_messages(email_id, opts = {})
      data, status_code, headers = get_emails_email_id_messages_with_http_info(email_id, opts)
      return data
    end

    # Get conversation messages
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmailMessageListing, Fixnum, Hash)>] EmailMessageListing data, response status code and response headers
    def get_emails_email_id_messages_with_http_info(email_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails_email_id_messages ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling get_emails_email_id_messages" if email_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/messages".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailMessageListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails_email_id_messages\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Send an email reply
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @option opts [EmailMessage] :body Reply
    # @return [EmailMessage]
    def post_emails_email_id_messages(email_id, opts = {})
      data, status_code, headers = post_emails_email_id_messages_with_http_info(email_id, opts)
      return data
    end

    # Send an email reply
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @option opts [EmailMessage] :body Reply
    # @return [Array<(EmailMessage, Fixnum, Hash)>] EmailMessage data, response status code and response headers
    def post_emails_email_id_messages_with_http_info(email_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_emails_email_id_messages ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling post_emails_email_id_messages" if email_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/messages".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailMessage')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_emails_email_id_messages\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get conversation draft reply
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @return [EmailMessage]
    def get_emails_email_id_messages_draft(email_id, opts = {})
      data, status_code, headers = get_emails_email_id_messages_draft_with_http_info(email_id, opts)
      return data
    end

    # Get conversation draft reply
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmailMessage, Fixnum, Hash)>] EmailMessage data, response status code and response headers
    def get_emails_email_id_messages_draft_with_http_info(email_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails_email_id_messages_draft ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling get_emails_email_id_messages_draft" if email_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/messages/draft".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailMessage')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails_email_id_messages_draft\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update conversation draft reply
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @option opts [EmailMessage] :body Draft
    # @return [EmailMessage]
    def put_emails_email_id_messages_draft(email_id, opts = {})
      data, status_code, headers = put_emails_email_id_messages_draft_with_http_info(email_id, opts)
      return data
    end

    # Update conversation draft reply
    # 
    # @param email_id 
    # @param [Hash] opts the optional parameters
    # @option opts [EmailMessage] :body Draft
    # @return [Array<(EmailMessage, Fixnum, Hash)>] EmailMessage data, response status code and response headers
    def put_emails_email_id_messages_draft_with_http_info(email_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#put_emails_email_id_messages_draft ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling put_emails_email_id_messages_draft" if email_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/messages/draft".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailMessage')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#put_emails_email_id_messages_draft\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete attachment from draft
    # 
    # @param email_id 
    # @param attachment_id 
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_emails_email_id_messages_draft_attachments_attachment_id(email_id, attachment_id, opts = {})
      data, status_code, headers = delete_emails_email_id_messages_draft_attachments_attachment_id_with_http_info(email_id, attachment_id, opts)
      return data
    end

    # Delete attachment from draft
    # 
    # @param email_id 
    # @param attachment_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_emails_email_id_messages_draft_attachments_attachment_id_with_http_info(email_id, attachment_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#delete_emails_email_id_messages_draft_attachments_attachment_id ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling delete_emails_email_id_messages_draft_attachments_attachment_id" if email_id.nil?
      
      # verify the required parameter 'attachment_id' is set
      fail "Missing the required parameter 'attachment_id' when calling delete_emails_email_id_messages_draft_attachments_attachment_id" if attachment_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/messages/draft/attachments/{attachmentId}".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'attachmentId' + '}', attachment_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#delete_emails_email_id_messages_draft_attachments_attachment_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get conversation message
    # 
    # @param email_id 
    # @param message_id 
    # @param [Hash] opts the optional parameters
    # @return [EmailMessage]
    def get_emails_email_id_messages_message_id(email_id, message_id, opts = {})
      data, status_code, headers = get_emails_email_id_messages_message_id_with_http_info(email_id, message_id, opts)
      return data
    end

    # Get conversation message
    # 
    # @param email_id 
    # @param message_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmailMessage, Fixnum, Hash)>] EmailMessage data, response status code and response headers
    def get_emails_email_id_messages_message_id_with_http_info(email_id, message_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails_email_id_messages_message_id ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling get_emails_email_id_messages_message_id" if email_id.nil?
      
      # verify the required parameter 'message_id' is set
      fail "Missing the required parameter 'message_id' when calling get_emails_email_id_messages_message_id" if message_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/messages/{messageId}".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'messageId' + '}', message_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EmailMessage')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails_email_id_messages_message_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update conversation participant
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [nil]
    def patch_emails_email_id_participants_participant_id(email_id, participant_id, opts = {})
      patch_emails_email_id_participants_participant_id_with_http_info(email_id, participant_id, opts)
      return nil
    end

    # Update conversation participant
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_emails_email_id_participants_participant_id_with_http_info(email_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_emails_email_id_participants_participant_id ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling patch_emails_email_id_participants_participant_id" if email_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_emails_email_id_participants_participant_id" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/participants/{participantId}".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_emails_email_id_participants_participant_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the attributes on a conversation participant.
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [nil]
    def patch_emails_email_id_participants_participant_id_attributes(email_id, participant_id, opts = {})
      patch_emails_email_id_participants_participant_id_attributes_with_http_info(email_id, participant_id, opts)
      return nil
    end

    # Update the attributes on a conversation participant.
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_emails_email_id_participants_participant_id_attributes_with_http_info(email_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_emails_email_id_participants_participant_id_attributes ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling patch_emails_email_id_participants_participant_id_attributes" if email_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_emails_email_id_participants_participant_id_attributes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/participants/{participantId}/attributes".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_emails_email_id_participants_participant_id_attributes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [nil]
    def post_emails_email_id_participants_participant_id_replace(email_id, participant_id, opts = {})
      post_emails_email_id_participants_participant_id_replace_with_http_info(email_id, participant_id, opts)
      return nil
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_emails_email_id_participants_participant_id_replace_with_http_info(email_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_emails_email_id_participants_participant_id_replace ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling post_emails_email_id_participants_participant_id_replace" if email_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_emails_email_id_participants_participant_id_replace" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/participants/{participantId}/replace".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_emails_email_id_participants_participant_id_replace\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [WrapupCode]
    def get_emails_email_id_participants_participant_id_wrapup(email_id, participant_id, opts = {})
      data, status_code, headers = get_emails_email_id_participants_participant_id_wrapup_with_http_info(email_id, participant_id, opts)
      return data
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_emails_email_id_participants_participant_id_wrapup_with_http_info(email_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails_email_id_participants_participant_id_wrapup ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling get_emails_email_id_participants_participant_id_wrapup" if email_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_emails_email_id_participants_participant_id_wrapup" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/participants/{participantId}/wrapup".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'provisional'] = opts[:'provisional'] if opts[:'provisional']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails_email_id_participants_participant_id_wrapup\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [WrapupCode]
    def get_emails_email_id_participants_participant_id_wrapupcodes(email_id, participant_id, opts = {})
      data, status_code, headers = get_emails_email_id_participants_participant_id_wrapupcodes_with_http_info(email_id, participant_id, opts)
      return data
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param email_id 
    # @param participant_id 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_emails_email_id_participants_participant_id_wrapupcodes_with_http_info(email_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_emails_email_id_participants_participant_id_wrapupcodes ..."
      end
      
      # verify the required parameter 'email_id' is set
      fail "Missing the required parameter 'email_id' when calling get_emails_email_id_participants_participant_id_wrapupcodes" if email_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_emails_email_id_participants_participant_id_wrapupcodes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/emails/{emailId}/participants/{participantId}/wrapupcodes".sub('{format}','json').sub('{' + 'emailId' + '}', email_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_emails_email_id_participants_participant_id_wrapupcodes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Fax Conversation
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [FaxSendRequest] :body Fax
    # @return [FaxSendResponse]
    def post_faxes(opts = {})
      data, status_code, headers = post_faxes_with_http_info(opts)
      return data
    end

    # Create Fax Conversation
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [FaxSendRequest] :body Fax
    # @return [Array<(FaxSendResponse, Fixnum, Hash)>] FaxSendResponse data, response status code and response headers
    def post_faxes_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_faxes ..."
      end
      
      # resource path
      path = "/api/v2/conversations/faxes".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'FaxSendResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_faxes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get conversation
    # 
    # @param conversation_id conversation ID
    # @param [Hash] opts the optional parameters
    # @return [Conversation]
    def get_conversation_id(conversation_id, opts = {})
      data, status_code, headers = get_conversation_id_with_http_info(conversation_id, opts)
      return data
    end

    # Get conversation
    # 
    # @param conversation_id conversation ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Conversation, Fixnum, Hash)>] Conversation data, response status code and response headers
    def get_conversation_id_with_http_info(conversation_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_conversation_id ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling get_conversation_id" if conversation_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Conversation')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_conversation_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a participant.
    # Update conversation participant.
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [nil]
    def patch_conversation_id_participants_participant_id(conversation_id, participant_id, opts = {})
      patch_conversation_id_participants_participant_id_with_http_info(conversation_id, participant_id, opts)
      return nil
    end

    # Update a participant.
    # Update conversation participant.
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [MediaParticipantRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_conversation_id_participants_participant_id_with_http_info(conversation_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_conversation_id_participants_participant_id ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling patch_conversation_id_participants_participant_id" if conversation_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_conversation_id_participants_participant_id" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}/participants/{participantId}".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_conversation_id_participants_participant_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the attributes on a conversation participant.
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [nil]
    def patch_conversation_id_participants_participant_id_attributes(conversation_id, participant_id, opts = {})
      patch_conversation_id_participants_participant_id_attributes_with_http_info(conversation_id, participant_id, opts)
      return nil
    end

    # Update the attributes on a conversation participant.
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [ParticipantAttributes] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def patch_conversation_id_participants_participant_id_attributes_with_http_info(conversation_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#patch_conversation_id_participants_participant_id_attributes ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling patch_conversation_id_participants_participant_id_attributes" if conversation_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling patch_conversation_id_participants_participant_id_attributes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}/participants/{participantId}/attributes".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#patch_conversation_id_participants_participant_id_attributes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a new callback for the specified participant on the conversation.
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [CreateCallbackCommand] :body 
    # @return [nil]
    def post_conversation_id_participants_participant_id_callbacks(conversation_id, participant_id, opts = {})
      post_conversation_id_participants_participant_id_callbacks_with_http_info(conversation_id, participant_id, opts)
      return nil
    end

    # Create a new callback for the specified participant on the conversation.
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [CreateCallbackCommand] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_conversation_id_participants_participant_id_callbacks_with_http_info(conversation_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_conversation_id_participants_participant_id_callbacks ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling post_conversation_id_participants_participant_id_callbacks" if conversation_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_conversation_id_participants_participant_id_callbacks" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}/participants/{participantId}/callbacks".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_conversation_id_participants_participant_id_callbacks\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [nil]
    def post_conversation_id_participants_participant_id_replace(conversation_id, participant_id, opts = {})
      post_conversation_id_participants_participant_id_replace_with_http_info(conversation_id, participant_id, opts)
      return nil
    end

    # Replace this participant with the specified user and/or address
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [TransferRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_conversation_id_participants_participant_id_replace_with_http_info(conversation_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#post_conversation_id_participants_participant_id_replace ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling post_conversation_id_participants_participant_id_replace" if conversation_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling post_conversation_id_participants_participant_id_replace" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}/participants/{participantId}/replace".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#post_conversation_id_participants_participant_id_replace\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [WrapupCode]
    def get_conversation_id_participants_participant_id_wrapup(conversation_id, participant_id, opts = {})
      data, status_code, headers = get_conversation_id_participants_participant_id_wrapup_with_http_info(conversation_id, participant_id, opts)
      return data
    end

    # Get the wrap-up for this conversation participant.
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @option opts [BOOLEAN] :provisional Indicates if the wrap-up code is provisional.
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_conversation_id_participants_participant_id_wrapup_with_http_info(conversation_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_conversation_id_participants_participant_id_wrapup ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling get_conversation_id_participants_participant_id_wrapup" if conversation_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_conversation_id_participants_participant_id_wrapup" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}/participants/{participantId}/wrapup".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'provisional'] = opts[:'provisional'] if opts[:'provisional']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_conversation_id_participants_participant_id_wrapup\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @return [WrapupCode]
    def get_conversation_id_participants_participant_id_wrapupcodes(conversation_id, participant_id, opts = {})
      data, status_code, headers = get_conversation_id_participants_participant_id_wrapupcodes_with_http_info(conversation_id, participant_id, opts)
      return data
    end

    # Get list of wrapup codes for this conversation participant
    # 
    # @param conversation_id conversation ID
    # @param participant_id participant ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(WrapupCode, Fixnum, Hash)>] WrapupCode data, response status code and response headers
    def get_conversation_id_participants_participant_id_wrapupcodes_with_http_info(conversation_id, participant_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConversationsApi#get_conversation_id_participants_participant_id_wrapupcodes ..."
      end
      
      # verify the required parameter 'conversation_id' is set
      fail "Missing the required parameter 'conversation_id' when calling get_conversation_id_participants_participant_id_wrapupcodes" if conversation_id.nil?
      
      # verify the required parameter 'participant_id' is set
      fail "Missing the required parameter 'participant_id' when calling get_conversation_id_participants_participant_id_wrapupcodes" if participant_id.nil?
      
      # resource path
      path = "/api/v2/conversations/{conversationId}/participants/{participantId}/wrapupcodes".sub('{format}','json').sub('{' + 'conversationId' + '}', conversation_id.to_s).sub('{' + 'participantId' + '}', participant_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'WrapupCode')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConversationsApi#get_conversation_id_participants_participant_id_wrapupcodes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end
  end
end