scc-firewall-manager-sdk 1.15.287__py3-none-any.whl → 1.15.563__py3-none-any.whl

scc_firewall_manager_sdk/api/msp_tenant_management_api.py

@@ -22,6 +22,7 @@ from typing import Optional
 from typing_extensions import Annotated
 from scc_firewall_manager_sdk.models.api_token_info import ApiTokenInfo
 from scc_firewall_manager_sdk.models.cdo_transaction import CdoTransaction
+from scc_firewall_manager_sdk.models.enable_cd_fmc_for_tenant_request import EnableCdFmcForTenantRequest
 from scc_firewall_manager_sdk.models.msp_add_tenant_input import MspAddTenantInput
 from scc_firewall_manager_sdk.models.msp_create_tenant_input import MspCreateTenantInput
 from scc_firewall_manager_sdk.models.msp_managed_tenant import MspManagedTenant
@@ -1713,8 +1714,8 @@ class MSPTenantManagementApi:
     @validate_call
     def get_msp_managed_tenants(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -1733,9 +1734,9 @@ class MSPTenantManagementApi:
 
         Get a list of Security Cloud Control tenants managed by the MSP Portal.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -1792,8 +1793,8 @@ class MSPTenantManagementApi:
     @validate_call
     def get_msp_managed_tenants_with_http_info(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -1812,9 +1813,9 @@ class MSPTenantManagementApi:
 
         Get a list of Security Cloud Control tenants managed by the MSP Portal.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -1871,8 +1872,8 @@ class MSPTenantManagementApi:
     @validate_call
     def get_msp_managed_tenants_without_preload_content(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -1891,9 +1892,9 @@ class MSPTenantManagementApi:
 
         Get a list of Security Cloud Control tenants managed by the MSP Portal.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -2020,6 +2021,7 @@ class MSPTenantManagementApi:
     def provision_cd_fmc_for_tenant_in_msp_portal(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant that cdFMC provisioning will be enabled for.")],
+        enable_cd_fmc_for_tenant_request: Optional[EnableCdFmcForTenantRequest] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2039,6 +2041,8 @@ class MSPTenantManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant that cdFMC provisioning will be enabled for. (required)
         :type tenant_uid: str
+        :param enable_cd_fmc_for_tenant_request:
+        :type enable_cd_fmc_for_tenant_request: EnableCdFmcForTenantRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2063,6 +2067,7 @@ class MSPTenantManagementApi:
 
         _param = self._provision_cd_fmc_for_tenant_in_msp_portal_serialize(
             tenant_uid=tenant_uid,
+            enable_cd_fmc_for_tenant_request=enable_cd_fmc_for_tenant_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2088,6 +2093,7 @@ class MSPTenantManagementApi:
     def provision_cd_fmc_for_tenant_in_msp_portal_with_http_info(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant that cdFMC provisioning will be enabled for.")],
+        enable_cd_fmc_for_tenant_request: Optional[EnableCdFmcForTenantRequest] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2107,6 +2113,8 @@ class MSPTenantManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant that cdFMC provisioning will be enabled for. (required)
         :type tenant_uid: str
+        :param enable_cd_fmc_for_tenant_request:
+        :type enable_cd_fmc_for_tenant_request: EnableCdFmcForTenantRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2131,6 +2139,7 @@ class MSPTenantManagementApi:
 
         _param = self._provision_cd_fmc_for_tenant_in_msp_portal_serialize(
             tenant_uid=tenant_uid,
+            enable_cd_fmc_for_tenant_request=enable_cd_fmc_for_tenant_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2156,6 +2165,7 @@ class MSPTenantManagementApi:
     def provision_cd_fmc_for_tenant_in_msp_portal_without_preload_content(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant that cdFMC provisioning will be enabled for.")],
+        enable_cd_fmc_for_tenant_request: Optional[EnableCdFmcForTenantRequest] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2175,6 +2185,8 @@ class MSPTenantManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant that cdFMC provisioning will be enabled for. (required)
         :type tenant_uid: str
+        :param enable_cd_fmc_for_tenant_request:
+        :type enable_cd_fmc_for_tenant_request: EnableCdFmcForTenantRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2199,6 +2211,7 @@ class MSPTenantManagementApi:
 
         _param = self._provision_cd_fmc_for_tenant_in_msp_portal_serialize(
             tenant_uid=tenant_uid,
+            enable_cd_fmc_for_tenant_request=enable_cd_fmc_for_tenant_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2219,6 +2232,7 @@ class MSPTenantManagementApi:
     def _provision_cd_fmc_for_tenant_in_msp_portal_serialize(
         self,
         tenant_uid,
+        enable_cd_fmc_for_tenant_request,
         _request_auth,
         _content_type,
         _headers,
@@ -2244,6 +2258,8 @@ class MSPTenantManagementApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if enable_cd_fmc_for_tenant_request is not None:
+            _body_params = enable_cd_fmc_for_tenant_request
 
 
         # set the HTTP header `Accept`
@@ -2253,6 +2269,19 @@ class MSPTenantManagementApi:
             ]
         )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [

scc_firewall_manager_sdk/api/msp_user_management_api.py

@@ -625,8 +625,8 @@ class MSPUserManagementApi:
     def get_api_only_users_in_msp_managed_tenant(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant to retrieve the users for.")],
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -647,9 +647,9 @@ class MSPUserManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant to retrieve the users for. (required)
         :type tenant_uid: str
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -705,8 +705,8 @@ class MSPUserManagementApi:
     def get_api_only_users_in_msp_managed_tenant_with_http_info(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant to retrieve the users for.")],
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -727,9 +727,9 @@ class MSPUserManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant to retrieve the users for. (required)
         :type tenant_uid: str
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -785,8 +785,8 @@ class MSPUserManagementApi:
     def get_api_only_users_in_msp_managed_tenant_without_preload_content(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant to retrieve the users for.")],
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -807,9 +807,9 @@ class MSPUserManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant to retrieve the users for. (required)
         :type tenant_uid: str
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -937,8 +937,8 @@ class MSPUserManagementApi:
     def get_human_users_in_msp_managed_tenant(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant to retrieve the users for.")],
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -959,9 +959,9 @@ class MSPUserManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant to retrieve the users for. (required)
         :type tenant_uid: str
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -1017,8 +1017,8 @@ class MSPUserManagementApi:
     def get_human_users_in_msp_managed_tenant_with_http_info(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant to retrieve the users for.")],
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -1039,9 +1039,9 @@ class MSPUserManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant to retrieve the users for. (required)
         :type tenant_uid: str
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -1097,8 +1097,8 @@ class MSPUserManagementApi:
     def get_human_users_in_msp_managed_tenant_without_preload_content(
         self,
         tenant_uid: Annotated[StrictStr, Field(description="Unique identifier of the tenant to retrieve the users for.")],
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -1119,9 +1119,9 @@ class MSPUserManagementApi:
 
         :param tenant_uid: Unique identifier of the tenant to retrieve the users for. (required)
         :type tenant_uid: str
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str

scc_firewall_manager_sdk/api/remote_access_monitoring_api.py

@@ -324,8 +324,8 @@ class RemoteAccessMonitoringApi:
     @validate_call
     def get_mfa_events(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         sort: Annotated[Optional[List[StrictStr]], Field(description="The fields to sort results by.")] = None,
         _request_timeout: Union[
@@ -345,9 +345,9 @@ class RemoteAccessMonitoringApi:
 
         Get a list of MFA events.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -408,8 +408,8 @@ class RemoteAccessMonitoringApi:
     @validate_call
     def get_mfa_events_with_http_info(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         sort: Annotated[Optional[List[StrictStr]], Field(description="The fields to sort results by.")] = None,
         _request_timeout: Union[
@@ -429,9 +429,9 @@ class RemoteAccessMonitoringApi:
 
         Get a list of MFA events.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -492,8 +492,8 @@ class RemoteAccessMonitoringApi:
     @validate_call
     def get_mfa_events_without_preload_content(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         sort: Annotated[Optional[List[StrictStr]], Field(description="The fields to sort results by.")] = None,
         _request_timeout: Union[
@@ -513,9 +513,9 @@ class RemoteAccessMonitoringApi:
 
         Get a list of MFA events.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -927,8 +927,8 @@ class RemoteAccessMonitoringApi:
     @validate_call
     def get_ra_vpn_sessions(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         sort: Annotated[Optional[List[StrictStr]], Field(description="The fields to sort results by.")] = None,
         _request_timeout: Union[
@@ -948,9 +948,9 @@ class RemoteAccessMonitoringApi:
 
         Get a list of RA VPN sessions.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -1011,8 +1011,8 @@ class RemoteAccessMonitoringApi:
     @validate_call
     def get_ra_vpn_sessions_with_http_info(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         sort: Annotated[Optional[List[StrictStr]], Field(description="The fields to sort results by.")] = None,
         _request_timeout: Union[
@@ -1032,9 +1032,9 @@ class RemoteAccessMonitoringApi:
 
         Get a list of RA VPN sessions.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -1095,8 +1095,8 @@ class RemoteAccessMonitoringApi:
     @validate_call
     def get_ra_vpn_sessions_without_preload_content(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         sort: Annotated[Optional[List[StrictStr]], Field(description="The fields to sort results by.")] = None,
         _request_timeout: Union[
@@ -1116,9 +1116,9 @@ class RemoteAccessMonitoringApi:
 
         Get a list of RA VPN sessions.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str

scc_firewall_manager_sdk/api/tenant_management_api.py

@@ -825,8 +825,8 @@ class TenantManagementApi:
     @validate_call
     def get_tenants(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -840,13 +840,13 @@ class TenantManagementApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> TenantPage:
-        """Get Tenants
+        """(Deprecated) Get Tenants
 
-        Get a list of tenants with which the Security Cloud Control user is associated.
+        Get a list of tenants with which the Security Cloud Control user is associated. This endpoint must be called using the access token of a human user associated with a tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -869,6 +869,7 @@ class TenantManagementApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("GET /v1/tenants is deprecated.", DeprecationWarning)
 
         _param = self._get_tenants_serialize(
             limit=limit,
@@ -900,8 +901,8 @@ class TenantManagementApi:
     @validate_call
     def get_tenants_with_http_info(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -915,13 +916,13 @@ class TenantManagementApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[TenantPage]:
-        """Get Tenants
+        """(Deprecated) Get Tenants
 
-        Get a list of tenants with which the Security Cloud Control user is associated.
+        Get a list of tenants with which the Security Cloud Control user is associated. This endpoint must be called using the access token of a human user associated with a tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -944,6 +945,7 @@ class TenantManagementApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("GET /v1/tenants is deprecated.", DeprecationWarning)
 
         _param = self._get_tenants_serialize(
             limit=limit,
@@ -975,8 +977,8 @@ class TenantManagementApi:
     @validate_call
     def get_tenants_without_preload_content(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -990,13 +992,13 @@ class TenantManagementApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get Tenants
+        """(Deprecated) Get Tenants
 
-        Get a list of tenants with which the Security Cloud Control user is associated.
+        Get a list of tenants with which the Security Cloud Control user is associated. This endpoint must be called using the access token of a human user associated with a tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1019,6 +1021,7 @@ class TenantManagementApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("GET /v1/tenants is deprecated.", DeprecationWarning)
 
         _param = self._get_tenants_serialize(
             limit=limit,