70.0.0

Author: PureCloud Jenkins

README.md

@@ -61,7 +61,7 @@ If connecting to a PureCloud environment other than mypurecloud.com (e.g. mypure
 
 ```{"language":"python"}
 region = PureCloudRegionHosts.us_east_1
-PureCloudPlatformClientV2.configuration.host = region.get_api_host
+PureCloudPlatformClientV2.configuration.host = region.get_api_host()
 ```
 
 ### Connect to a Proxy Server

build/PureCloudPlatformClientV2/__init__.py

@@ -134,6 +134,7 @@
 from .models.billing_usage_report import BillingUsageReport
 from .models.billing_usage_resource import BillingUsageResource
 from .models.biography import Biography
+from .models.bu_search_agent_schedules_request import BuSearchAgentSchedulesRequest
 from .models.bullseye import Bullseye
 from .models.business_unit_reference import BusinessUnitReference
 from .models.calibration import Calibration
@@ -920,6 +921,7 @@
 from .models.logical_interface_entity_listing import LogicalInterfaceEntityListing
 from .models.management_unit import ManagementUnit
 from .models.management_unit_listing import ManagementUnitListing
+from .models.management_unit_reference import ManagementUnitReference
 from .models.management_unit_settings_request import ManagementUnitSettingsRequest
 from .models.management_unit_settings_response import ManagementUnitSettingsResponse
 from .models.manager import Manager
@@ -1406,6 +1408,8 @@
 from .models.segment_detail_query_filter import SegmentDetailQueryFilter
 from .models.segment_detail_query_predicate import SegmentDetailQueryPredicate
 from .models.selected_columns import SelectedColumns
+from .models.send_agentless_outbound_message_request import SendAgentlessOutboundMessageRequest
+from .models.send_agentless_outbound_message_response import SendAgentlessOutboundMessageResponse
 from .models.sequence_schedule import SequenceSchedule
 from .models.server_date import ServerDate
 from .models.service_context import ServiceContext
@@ -1525,6 +1529,7 @@
 from .models.token import Token
 from .models.token_info import TokenInfo
 from .models.transcript_property import TranscriptProperty
+from .models.transcription_settings import TranscriptionSettings
 from .models.transfer_request import TransferRequest
 from .models.trunk import Trunk
 from .models.trunk_base import TrunkBase
@@ -1749,6 +1754,7 @@
 from .models.whats_app_id import WhatsAppId
 from .models.whats_app_integration import WhatsAppIntegration
 from .models.whats_app_integration_entity_listing import WhatsAppIntegrationEntityListing
+from .models.whats_app_integration_request import WhatsAppIntegrationRequest
 from .models.whats_app_integration_update_request import WhatsAppIntegrationUpdateRequest
 from .models.widget_client_config import WidgetClientConfig
 from .models.widget_client_config_third_party import WidgetClientConfigThirdParty

build/PureCloudPlatformClientV2/api_client.py

@@ -185,7 +185,7 @@ def __call_api(self, resource_path, method,
             header_params['Cookie'] = self.cookie
         if header_params:
             header_params = self.sanitize_for_serialization(header_params)
-        header_params['purecloud-sdk'] = '69.0.0'
+        header_params['purecloud-sdk'] = '70.0.0'
 
         # path parameters
         if path_params:

build/PureCloudPlatformClientV2/apis/conversations_api.py

@@ -700,6 +700,84 @@ def delete_conversations_messaging_integrations_twitter_integration_id(self, int
                                             callback=params.get('callback'))
         return response
 
+    def delete_conversations_messaging_integrations_whatsapp_integration_id(self, integration_id, **kwargs):
+        """
+        Delete a WhatsApp messaging integration
+        
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please define a `callback` function
+        to be invoked when receiving the response.
+        >>> def callback_function(response):
+        >>>     pprint(response)
+        >>>
+        >>> thread = api.delete_conversations_messaging_integrations_whatsapp_integration_id(integration_id, callback=callback_function)
+
+        :param callback function: The callback function
+            for asynchronous request. (optional)
+        :param str integration_id: Integration ID (required)
+        :return: WhatsAppIntegration
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['integration_id']
+        all_params.append('callback')
+
+        params = locals()
+        for key, val in iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_conversations_messaging_integrations_whatsapp_integration_id" % key
+                )
+            params[key] = val
+        del params['kwargs']
+
+        # verify the required parameter 'integration_id' is set
+        if ('integration_id' not in params) or (params['integration_id'] is None):
+            raise ValueError("Missing the required parameter `integration_id` when calling `delete_conversations_messaging_integrations_whatsapp_integration_id`")
+
+
+        resource_path = '/api/v2/conversations/messaging/integrations/whatsapp/{integrationId}'.replace('{format}', 'json')
+        path_params = {}
+        if 'integration_id' in params:
+            path_params['integrationId'] = params['integration_id']
+
+        query_params = {}
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.\
+            select_header_accept(['application/json'])
+        if not header_params['Accept']:
+            del header_params['Accept']
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.\
+            select_header_content_type(['application/json'])
+
+        # Authentication setting
+        auth_settings = ['PureCloud OAuth']
+
+        response = self.api_client.call_api(resource_path, 'DELETE',
+                                            path_params,
+                                            query_params,
+                                            header_params,
+                                            body=body_params,
+                                            post_params=form_params,
+                                            files=local_var_files,
+                                            response_type='WhatsAppIntegration',
+                                            auth_settings=auth_settings,
+                                            callback=params.get('callback'))
+        return response
+
     def get_analytics_conversation_details(self, conversation_id, **kwargs):
         """
         Get a conversation by id
@@ -10159,6 +10237,84 @@ def post_conversations_messages(self, body, **kwargs):
                                             callback=params.get('callback'))
         return response
 
+    def post_conversations_messages_agentless(self, body, **kwargs):
+        """
+        Send an agentless outbound message
+        Send an agentlesss (api participant) outbound message using a client credential grant. In order to call this endpoint you will need OAuth token generated using OAuth client credentials authorized with at least messaging scope. This will generate a new Conversation, if there is an existing active Conversation between the fromAddress and toAddress already, then this POST will fail.
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please define a `callback` function
+        to be invoked when receiving the response.
+        >>> def callback_function(response):
+        >>>     pprint(response)
+        >>>
+        >>> thread = api.post_conversations_messages_agentless(body, callback=callback_function)
+
+        :param callback function: The callback function
+            for asynchronous request. (optional)
+        :param SendAgentlessOutboundMessageRequest body: Create agentless outbound messaging request (required)
+        :return: SendAgentlessOutboundMessageResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']
+        all_params.append('callback')
+
+        params = locals()
+        for key, val in iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method post_conversations_messages_agentless" % key
+                )
+            params[key] = val
+        del params['kwargs']
+
+        # verify the required parameter 'body' is set
+        if ('body' not in params) or (params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `post_conversations_messages_agentless`")
+
+
+        resource_path = '/api/v2/conversations/messages/agentless'.replace('{format}', 'json')
+        path_params = {}
+
+        query_params = {}
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.\
+            select_header_accept(['application/json'])
+        if not header_params['Accept']:
+            del header_params['Accept']
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.\
+            select_header_content_type(['application/json'])
+
+        # Authentication setting
+        auth_settings = ['PureCloud OAuth']
+
+        response = self.api_client.call_api(resource_path, 'POST',
+                                            path_params,
+                                            query_params,
+                                            header_params,
+                                            body=body_params,
+                                            post_params=form_params,
+                                            files=local_var_files,
+                                            response_type='SendAgentlessOutboundMessageResponse',
+                                            auth_settings=auth_settings,
+                                            callback=params.get('callback'))
+        return response
+
     def post_conversations_messaging_integrations_facebook(self, body, **kwargs):
         """
         Create a Facebook Integration
@@ -10393,6 +10549,84 @@ def post_conversations_messaging_integrations_twitter(self, body, **kwargs):
                                             callback=params.get('callback'))
         return response
 
+    def post_conversations_messaging_integrations_whatsapp(self, body, **kwargs):
+        """
+        Create a WhatsApp Integration
+        
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please define a `callback` function
+        to be invoked when receiving the response.
+        >>> def callback_function(response):
+        >>>     pprint(response)
+        >>>
+        >>> thread = api.post_conversations_messaging_integrations_whatsapp(body, callback=callback_function)
+
+        :param callback function: The callback function
+            for asynchronous request. (optional)
+        :param WhatsAppIntegrationRequest body: WhatsAppIntegrationRequest (required)
+        :return: WhatsAppIntegration
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']
+        all_params.append('callback')
+
+        params = locals()
+        for key, val in iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method post_conversations_messaging_integrations_whatsapp" % key
+                )
+            params[key] = val
+        del params['kwargs']
+
+        # verify the required parameter 'body' is set
+        if ('body' not in params) or (params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `post_conversations_messaging_integrations_whatsapp`")
+
+
+        resource_path = '/api/v2/conversations/messaging/integrations/whatsapp'.replace('{format}', 'json')
+        path_params = {}
+
+        query_params = {}
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.\
+            select_header_accept(['application/json'])
+        if not header_params['Accept']:
+            del header_params['Accept']
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.\
+            select_header_content_type(['application/json'])
+
+        # Authentication setting
+        auth_settings = ['PureCloud OAuth']
+
+        response = self.api_client.call_api(resource_path, 'POST',
+                                            path_params,
+                                            query_params,
+                                            header_params,
+                                            body=body_params,
+                                            post_params=form_params,
+                                            files=local_var_files,
+                                            response_type='WhatsAppIntegration',
+                                            auth_settings=auth_settings,
+                                            callback=params.get('callback'))
+        return response
+
     def put_conversation_participant_flaggedreason(self, conversation_id, participant_id, **kwargs):
         """
         Set flagged reason on conversation participant to indicate bad conversation quality.