208.0.0

build/PureCloudPlatformClientV2/api_client.py

@@ -357,7 +357,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'] = '207.0.0'
+        header_params['purecloud-sdk'] = '208.0.0'
 
         # path parameters
         if path_params:

build/PureCloudPlatformClientV2/apis/analytics_api.py

@@ -6264,8 +6264,8 @@ def post_analytics_queues_observations_query(self, body: 'QueueObservationQuery'
 
     def post_analytics_ratelimits_aggregates_query(self, body: 'RateLimitAggregationQuery', **kwargs) -> 'RateLimitAggregateQueryResponse':
         """
-        Query for limits rate limit aggregates. Data populated when limits are exceeded or are close to being exceeded. Not a source of truth for limits hit but a best effort estimate.
-        The 'max' property can be used to determine estimated rate limit value hit.
+        Query for limits rate limit aggregates. Data populated when limits reach 90% of the maximum. Not a source of truth for limits hit but a best effort estimate.
+        The 'max' property can be used to determine estimated rate limit value hit. See https://developer.genesys.cloud/organization/organization/limits#available-limits for limits that are trackable (Operational Events Enabled).
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please define a `callback` function

build/PureCloudPlatformClientV2/apis/integrations_api.py

@@ -85,6 +85,7 @@
 from ..models import SttEngineEntity
 from ..models import SttEngineEntityListing
 from ..models import TestExecutionResult
+from ..models import TrustedCertificates
 from ..models import TtsEngineEntity
 from ..models import TtsEngineEntityListing
 from ..models import TtsSettings
@@ -1706,6 +1707,78 @@ def get_integrations_actions_certificates(self, **kwargs) -> 'ActionCertificateL
                                             callback=params.get('callback'))
         return response
 
+    def get_integrations_actions_certificates_truststore(self, **kwargs) -> 'TrustedCertificates':
+        """
+        Retrieves basic info about trusted root CA certificates
+        
+
+        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.get_integrations_actions_certificates_truststore(callback=callback_function)
+
+        :param callback function: The callback function
+            for asynchronous request. (optional)
+        :return: TrustedCertificates
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = []
+        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 get_integrations_actions_certificates_truststore" % key
+                )
+            params[key] = val
+        del params['kwargs']
+
+
+
+        resource_path = '/api/v2/integrations/actions/certificates/truststore'.replace('{format}', 'json')
+        path_params = {}
+
+        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, 'GET',
+                                            path_params,
+                                            query_params,
+                                            header_params,
+                                            body=body_params,
+                                            post_params=form_params,
+                                            files=local_var_files,
+                                            response_type='TrustedCertificates',
+                                            auth_settings=auth_settings,
+                                            callback=params.get('callback'))
+        return response
+
     def get_integrations_actions_drafts(self, **kwargs) -> 'ActionEntityListing':
         """
         Retrieves all action drafts associated with the filters passed in via query param.

build/PureCloudPlatformClientV2/apis/learning_api.py

@@ -447,7 +447,7 @@ def get_learning_assignments(self, **kwargs) -> 'LearningAssignmentsDomainEntity
         :param str sort_order: Specifies result set sort order; if not specified, default sort order is descending (Desc)
         :param str sort_by: Specifies which field to sort the results by, default sort is by recommendedCompletionDate
         :param list[str] user_id: Specifies the list of user IDs to be queried, up to 100 user IDs.
-        :param list[str] types: Specifies the module types to filter by
+        :param list[str] types: Specifies the module types to filter by. Informational, AssessedContent and Assessment are deprecated
         :param list[str] states: Specifies the assignment states to filter by
         :param list[str] expand: Specifies the expand option for returning additional information
         :return: LearningAssignmentsDomainEntity
@@ -563,7 +563,7 @@ def get_learning_assignments_me(self, **kwargs) -> 'LearningAssignmentsDomainEnt
         :param float max_percentage_score: The maximum assessment score for an assignment (completed with assessment) to be included in the results (inclusive)
         :param str sort_order: Specifies result set sort order; if not specified, default sort order is descending (Desc)
         :param str sort_by: Specifies which field to sort the results by, default sort is by recommendedCompletionDate
-        :param list[str] types: Specifies the module types to filter by
+        :param list[str] types: Specifies the module types to filter by. Informational, AssessedContent and Assessment are deprecated
         :param list[str] states: Specifies the assignment states to filter by
         :param list[str] expand: Specifies the expand option for returning additional information
         :return: LearningAssignmentsDomainEntity
@@ -1075,7 +1075,7 @@ def get_learning_modules(self, **kwargs) -> 'LearningModulesDomainEntityListing'
         :param callback function: The callback function
             for asynchronous request. (optional)
         :param bool is_archived: Archive status
-        :param list[str] types: Specifies the module types.
+        :param list[str] types: Specifies the module types. Informational, AssessedContent and Assessment are deprecated
         :param int page_size: Page size
         :param int page_number: Page number
         :param str sort_order: Sort order

build/PureCloudPlatformClientV2/apis/organization_api.py

@@ -46,6 +46,7 @@
 from ..models import IpAddressAuthentication
 from ..models import LimitChangeRequestDetails
 from ..models import LimitChangeRequestsEntityListing
+from ..models import LimitCountListing
 from ..models import LimitDocumentation
 from ..models import LimitsEntityListing
 from ..models import OrgAuthSettings
@@ -753,6 +754,93 @@ def get_organizations_limits_namespace(self, namespace_name: str, **kwargs) -> '
                                             callback=params.get('callback'))
         return response
 
+    def get_organizations_limits_namespace_counts(self, namespace_name: str, **kwargs) -> 'LimitCountListing':
+        """
+        Get estimated limit counts for a namespace. This is not a source of truth for limit values but a record of estimates to facilitate limit threshold tracking.
+        See https://developer.genesys.cloud/organization/organization/limits#available-limits for limits that are trackable (Operational Events Enabled).
+
+        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.get_organizations_limits_namespace_counts(namespace_name, callback=callback_function)
+
+        :param callback function: The callback function
+            for asynchronous request. (optional)
+        :param str namespace_name: The namespace to get (required)
+        :param str cursor: Cursor provided when retrieving the last page
+        :param str entity_id: entity id of the count
+        :param str user_id: userid of the count
+        :return: LimitCountListing
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['namespace_name', 'cursor', 'entity_id', 'user_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 get_organizations_limits_namespace_counts" % key
+                )
+            params[key] = val
+        del params['kwargs']
+
+        # verify the required parameter 'namespace_name' is set
+        if ('namespace_name' not in params) or (params['namespace_name'] is None):
+            raise ValueError("Missing the required parameter `namespace_name` when calling `get_organizations_limits_namespace_counts`")
+
+
+        resource_path = '/api/v2/organizations/limits/namespaces/{namespaceName}/counts'.replace('{format}', 'json')
+        path_params = {}
+        if 'namespace_name' in params:
+            path_params['namespaceName'] = params['namespace_name']
+
+        query_params = {}
+        if 'cursor' in params:
+            query_params['cursor'] = params['cursor']
+        if 'entity_id' in params:
+            query_params['entityId'] = params['entity_id']
+        if 'user_id' in params:
+            query_params['userId'] = params['user_id']
+
+        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, 'GET',
+                                            path_params,
+                                            query_params,
+                                            header_params,
+                                            body=body_params,
+                                            post_params=form_params,
+                                            files=local_var_files,
+                                            response_type='LimitCountListing',
+                                            auth_settings=auth_settings,
+                                            callback=params.get('callback'))
+        return response
+
     def get_organizations_limits_namespace_defaults(self, namespace_name: str, **kwargs) -> 'LimitsEntityListing':
         """
         Get the default limits in a namespace for an organization
@@ -831,6 +919,99 @@ def get_organizations_limits_namespace_defaults(self, namespace_name: str, **kwa
                                             callback=params.get('callback'))
         return response
 
+    def get_organizations_limits_namespace_limit_counts(self, namespace_name: str, limit_name: str, **kwargs) -> 'LimitCountListing':
+        """
+        Get estimated limit counts for a namespace and limit name. This is not a source of truth for limit values but a record of estimates to facilitate limit threshold tracking.
+        See https://developer.genesys.cloud/organization/organization/limits#available-limits for limits that are trackable (Operational Events Enabled).
+
+        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.get_organizations_limits_namespace_limit_counts(namespace_name, limit_name, callback=callback_function)
+
+        :param callback function: The callback function
+            for asynchronous request. (optional)
+        :param str namespace_name: The namespace to get (required)
+        :param str limit_name: The limit to get (required)
+        :param str entity_id: entity id of the count
+        :param str user_id: userid of the count
+        :param str cursor: Cursor provided when retrieving the last page
+        :return: LimitCountListing
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['namespace_name', 'limit_name', 'entity_id', 'user_id', 'cursor']
+        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 get_organizations_limits_namespace_limit_counts" % key
+                )
+            params[key] = val
+        del params['kwargs']
+
+        # verify the required parameter 'namespace_name' is set
+        if ('namespace_name' not in params) or (params['namespace_name'] is None):
+            raise ValueError("Missing the required parameter `namespace_name` when calling `get_organizations_limits_namespace_limit_counts`")
+        # verify the required parameter 'limit_name' is set
+        if ('limit_name' not in params) or (params['limit_name'] is None):
+            raise ValueError("Missing the required parameter `limit_name` when calling `get_organizations_limits_namespace_limit_counts`")
+
+
+        resource_path = '/api/v2/organizations/limits/namespaces/{namespaceName}/limits/{limitName}/counts'.replace('{format}', 'json')
+        path_params = {}
+        if 'namespace_name' in params:
+            path_params['namespaceName'] = params['namespace_name']
+        if 'limit_name' in params:
+            path_params['limitName'] = params['limit_name']
+
+        query_params = {}
+        if 'entity_id' in params:
+            query_params['entityId'] = params['entity_id']
+        if 'user_id' in params:
+            query_params['userId'] = params['user_id']
+        if 'cursor' in params:
+            query_params['cursor'] = params['cursor']
+
+        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, 'GET',
+                                            path_params,
+                                            query_params,
+                                            header_params,
+                                            body=body_params,
+                                            post_params=form_params,
+                                            files=local_var_files,
+                                            response_type='LimitCountListing',
+                                            auth_settings=auth_settings,
+                                            callback=params.get('callback'))
+        return response
+
     def get_organizations_limits_namespaces(self, **kwargs) -> object:
         """
         Get the available limit namespaces