scc-firewall-manager-sdk 1.15.371__py3-none-any.whl → 1.15.389__py3-none-any.whl

scc_firewall_manager_sdk/__init__.py

@@ -15,7 +15,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.15.371"
+__version__ = "1.15.389"
 
 # import apis into sdk package
 from scc_firewall_manager_sdk.api.ai_assistant_api import AIAssistantApi
@@ -119,6 +119,7 @@ from scc_firewall_manager_sdk.models.command_response import CommandResponse
 from scc_firewall_manager_sdk.models.common_api_error import CommonApiError
 from scc_firewall_manager_sdk.models.compatible_device_dto import CompatibleDeviceDto
 from scc_firewall_manager_sdk.models.compatible_version_info_dto import CompatibleVersionInfoDto
+from scc_firewall_manager_sdk.models.completion_status_dto import CompletionStatusDto
 from scc_firewall_manager_sdk.models.config_state import ConfigState
 from scc_firewall_manager_sdk.models.conflict_detection_interval import ConflictDetectionInterval
 from scc_firewall_manager_sdk.models.conflict_detection_state import ConflictDetectionState
@@ -233,6 +234,7 @@ from scc_firewall_manager_sdk.models.msp_managed_template_distinct_attribute_val
 from scc_firewall_manager_sdk.models.msp_managed_templates_page import MspManagedTemplatesPage
 from scc_firewall_manager_sdk.models.msp_managed_tenant import MspManagedTenant
 from scc_firewall_manager_sdk.models.msp_managed_tenant_page import MspManagedTenantPage
+from scc_firewall_manager_sdk.models.msp_upgrade_ftd_devices_input import MspUpgradeFtdDevicesInput
 from scc_firewall_manager_sdk.models.msp_upgrade_run_dto import MspUpgradeRunDto
 from scc_firewall_manager_sdk.models.msp_upgrade_run_dto_page import MspUpgradeRunDtoPage
 from scc_firewall_manager_sdk.models.msp_upgrade_runs_attribute_values import MspUpgradeRunsAttributeValues

scc_firewall_manager_sdk/api/asa_interfaces_api.py

@@ -2104,8 +2104,8 @@ class ASAInterfacesApi:
     def get_asa_ether_channel_interfaces(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -2127,9 +2127,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -2191,8 +2191,8 @@ class ASAInterfacesApi:
     def get_asa_ether_channel_interfaces_with_http_info(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -2214,9 +2214,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -2278,8 +2278,8 @@ class ASAInterfacesApi:
     def get_asa_ether_channel_interfaces_without_preload_content(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -2301,9 +2301,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -2444,8 +2444,8 @@ class ASAInterfacesApi:
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
         interface_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the ASA parent interface.")],
-        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[
@@ -2469,9 +2469,9 @@ class ASAInterfacesApi:
         :type device_uid: str
         :param interface_uid: Unique identifier (UUID) of the ASA parent interface. (required)
         :type interface_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
@@ -2535,8 +2535,8 @@ class ASAInterfacesApi:
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
         interface_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the ASA parent interface.")],
-        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[
@@ -2560,9 +2560,9 @@ class ASAInterfacesApi:
         :type device_uid: str
         :param interface_uid: Unique identifier (UUID) of the ASA parent interface. (required)
         :type interface_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
@@ -2626,8 +2626,8 @@ class ASAInterfacesApi:
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
         interface_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the ASA parent interface.")],
-        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[
@@ -2651,9 +2651,9 @@ class ASAInterfacesApi:
         :type device_uid: str
         :param interface_uid: Unique identifier (UUID) of the ASA parent interface. (required)
         :type interface_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
@@ -3085,8 +3085,8 @@ class ASAInterfacesApi:
     def get_asa_physical_interfaces(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -3108,9 +3108,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -3172,8 +3172,8 @@ class ASAInterfacesApi:
     def get_asa_physical_interfaces_with_http_info(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -3195,9 +3195,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -3259,8 +3259,8 @@ class ASAInterfacesApi:
     def get_asa_physical_interfaces_without_preload_content(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -3282,9 +3282,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -3712,8 +3712,8 @@ class ASAInterfacesApi:
     def get_asa_sub_interfaces(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -3735,9 +3735,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -3799,8 +3799,8 @@ class ASAInterfacesApi:
     def get_asa_sub_interfaces_with_http_info(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -3822,9 +3822,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -3886,8 +3886,8 @@ class ASAInterfacesApi:
     def get_asa_sub_interfaces_without_preload_content(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -3909,9 +3909,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -4339,8 +4339,8 @@ class ASAInterfacesApi:
     def get_asa_virtual_tunnel_interfaces(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -4362,9 +4362,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -4426,8 +4426,8 @@ class ASAInterfacesApi:
     def get_asa_virtual_tunnel_interfaces_with_http_info(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -4449,9 +4449,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -4513,8 +4513,8 @@ class ASAInterfacesApi:
     def get_asa_virtual_tunnel_interfaces_without_preload_content(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -4536,9 +4536,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -4966,8 +4966,8 @@ class ASAInterfacesApi:
     def get_asa_vlan_interfaces(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -4989,9 +4989,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -5053,8 +5053,8 @@ class ASAInterfacesApi:
     def get_asa_vlan_interfaces_with_http_info(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -5076,9 +5076,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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
@@ -5140,8 +5140,8 @@ class ASAInterfacesApi:
     def get_asa_vlan_interfaces_without_preload_content(
         self,
         device_uid: Annotated[StrictStr, Field(description="Unique identifier (UUID) of the device.")],
-        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[
@@ -5163,9 +5163,9 @@ class ASAInterfacesApi:
 
         :param device_uid: Unique identifier (UUID) of the device. (required)
         :type device_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/device_health_aggregations_api.py

@@ -48,7 +48,7 @@ class DeviceHealthAggregationsApi:
         threshold: Annotated[StrictStr, Field(description="The metric threshold (e.g. CRITICAL).")],
         aggregation_period: Annotated[Optional[StrictStr], Field(description="The aggregation period of the metrics returned.")] = None,
         managed_tenant_uid: Annotated[Optional[StrictStr], Field(description="A managed tenant UUID to filter list, if applicable.")] = None,
-        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.")] = None,
+        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -74,7 +74,7 @@ class DeviceHealthAggregationsApi:
         :type aggregation_period: str
         :param managed_tenant_uid: A managed tenant UUID to filter list, if applicable.
         :type managed_tenant_uid: str
-        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.
+        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.
         :type q: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -136,7 +136,7 @@ class DeviceHealthAggregationsApi:
         threshold: Annotated[StrictStr, Field(description="The metric threshold (e.g. CRITICAL).")],
         aggregation_period: Annotated[Optional[StrictStr], Field(description="The aggregation period of the metrics returned.")] = None,
         managed_tenant_uid: Annotated[Optional[StrictStr], Field(description="A managed tenant UUID to filter list, if applicable.")] = None,
-        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.")] = None,
+        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -162,7 +162,7 @@ class DeviceHealthAggregationsApi:
         :type aggregation_period: str
         :param managed_tenant_uid: A managed tenant UUID to filter list, if applicable.
         :type managed_tenant_uid: str
-        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.
+        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.
         :type q: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -224,7 +224,7 @@ class DeviceHealthAggregationsApi:
         threshold: Annotated[StrictStr, Field(description="The metric threshold (e.g. CRITICAL).")],
         aggregation_period: Annotated[Optional[StrictStr], Field(description="The aggregation period of the metrics returned.")] = None,
         managed_tenant_uid: Annotated[Optional[StrictStr], Field(description="A managed tenant UUID to filter list, if applicable.")] = None,
-        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.")] = None,
+        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -250,7 +250,7 @@ class DeviceHealthAggregationsApi:
         :type aggregation_period: str
         :param managed_tenant_uid: A managed tenant UUID to filter list, if applicable.
         :type managed_tenant_uid: str
-        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.
+        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.
         :type q: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request

scc_firewall_manager_sdk/api/device_upgrades_api.py

@@ -1444,8 +1444,8 @@ class DeviceUpgradesApi:
     @validate_call
     def get_device_upgrade_runs(
         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[
@@ -1465,9 +1465,9 @@ class DeviceUpgradesApi:
 
         Get a list of FTD device upgrade runs in the SCC Firewall Manager Tenant. Each upgrade run represents a group of devices being upgraded, or staged for upgrades, together.
 
-        :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
@@ -1527,8 +1527,8 @@ class DeviceUpgradesApi:
     @validate_call
     def get_device_upgrade_runs_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[
@@ -1548,9 +1548,9 @@ class DeviceUpgradesApi:
 
         Get a list of FTD device upgrade runs in the SCC Firewall Manager Tenant. Each upgrade run represents a group of devices being upgraded, or staged for upgrades, together.
 
-        :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
@@ -1610,8 +1610,8 @@ class DeviceUpgradesApi:
     @validate_call
     def get_device_upgrade_runs_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[
@@ -1631,9 +1631,9 @@ class DeviceUpgradesApi:
 
         Get a list of FTD device upgrade runs in the SCC Firewall Manager Tenant. Each upgrade run represents a group of devices being upgraded, or staged for upgrades, together.
 
-        :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/interface_health_aggregations_api.py

@@ -49,7 +49,7 @@ class InterfaceHealthAggregationsApi:
         threshold: Annotated[StrictStr, Field(description="The metric threshold (e.g. CRITICAL).")],
         aggregation_period: Annotated[Optional[StrictStr], Field(description="The aggregation period of the metrics returned.")] = None,
         managed_tenant_uid: Annotated[Optional[StrictStr], Field(description="A managed tenant UUID to filter list, if applicable.")] = None,
-        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.")] = None,
+        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -75,7 +75,7 @@ class InterfaceHealthAggregationsApi:
         :type aggregation_period: str
         :param managed_tenant_uid: A managed tenant UUID to filter list, if applicable.
         :type managed_tenant_uid: str
-        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.
+        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.
         :type q: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -137,7 +137,7 @@ class InterfaceHealthAggregationsApi:
         threshold: Annotated[StrictStr, Field(description="The metric threshold (e.g. CRITICAL).")],
         aggregation_period: Annotated[Optional[StrictStr], Field(description="The aggregation period of the metrics returned.")] = None,
         managed_tenant_uid: Annotated[Optional[StrictStr], Field(description="A managed tenant UUID to filter list, if applicable.")] = None,
-        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.")] = None,
+        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -163,7 +163,7 @@ class InterfaceHealthAggregationsApi:
         :type aggregation_period: str
         :param managed_tenant_uid: A managed tenant UUID to filter list, if applicable.
         :type managed_tenant_uid: str
-        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.
+        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.
         :type q: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -225,7 +225,7 @@ class InterfaceHealthAggregationsApi:
         threshold: Annotated[StrictStr, Field(description="The metric threshold (e.g. CRITICAL).")],
         aggregation_period: Annotated[Optional[StrictStr], Field(description="The aggregation period of the metrics returned.")] = None,
         managed_tenant_uid: Annotated[Optional[StrictStr], Field(description="A managed tenant UUID to filter list, if applicable.")] = None,
-        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.")] = None,
+        q: Annotated[Optional[StrictStr], Field(description="Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -251,7 +251,7 @@ class InterfaceHealthAggregationsApi:
         :type aggregation_period: str
         :param managed_tenant_uid: A managed tenant UUID to filter list, if applicable.
         :type managed_tenant_uid: str
-        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) are supported for filtering.
+        :param q: Lucene-style query filter. Only prefix queries (e.g. field:value*) and wildcard queries (e.g. field:*value or field:*value*) are supported for filtering.
         :type q: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request

scc_firewall_manager_sdk/api/msp_device_upgrades_api.py

@@ -22,6 +22,7 @@ from typing import List, Optional
 from typing_extensions import Annotated
 from scc_firewall_manager_sdk.models.cdo_transaction import CdoTransaction
 from scc_firewall_manager_sdk.models.msp_calculate_compatible_upgrade_versions_input import MspCalculateCompatibleUpgradeVersionsInput
+from scc_firewall_manager_sdk.models.msp_upgrade_ftd_devices_input import MspUpgradeFtdDevicesInput
 from scc_firewall_manager_sdk.models.msp_upgrade_run_dto import MspUpgradeRunDto
 from scc_firewall_manager_sdk.models.msp_upgrade_run_dto_page import MspUpgradeRunDtoPage
 from scc_firewall_manager_sdk.models.msp_upgrade_runs_attribute_values import MspUpgradeRunsAttributeValues
@@ -1696,6 +1697,7 @@ class MSPDeviceUpgradesApi:
     @validate_call
     def upgrade_msp_managed_ftd_devices(
         self,
+        msp_upgrade_ftd_devices_input: MspUpgradeFtdDevicesInput,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1713,6 +1715,8 @@ class MSPDeviceUpgradesApi:
 
         <p>Asynchronous operation to upgrade multiple FTD devices across managed tenants.</p> <p><strong>Notes:</strong></p> <ul> <li>Maximum of 50 FTD devices per hardware model per managed tenant per request</li> </ul> <p><strong>Response:</strong></p> <ul> <li>Returns a transaction object to track upgrade operation progress</li> <li>Use the transaction ID or the entity UID to monitor the status of the upgrade</li> </ul>
 
+        :param msp_upgrade_ftd_devices_input: (required)
+        :type msp_upgrade_ftd_devices_input: MspUpgradeFtdDevicesInput
         :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
@@ -1736,6 +1740,7 @@ class MSPDeviceUpgradesApi:
         """ # noqa: E501
 
         _param = self._upgrade_msp_managed_ftd_devices_serialize(
+            msp_upgrade_ftd_devices_input=msp_upgrade_ftd_devices_input,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1760,6 +1765,7 @@ class MSPDeviceUpgradesApi:
     @validate_call
     def upgrade_msp_managed_ftd_devices_with_http_info(
         self,
+        msp_upgrade_ftd_devices_input: MspUpgradeFtdDevicesInput,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1777,6 +1783,8 @@ class MSPDeviceUpgradesApi:
 
         <p>Asynchronous operation to upgrade multiple FTD devices across managed tenants.</p> <p><strong>Notes:</strong></p> <ul> <li>Maximum of 50 FTD devices per hardware model per managed tenant per request</li> </ul> <p><strong>Response:</strong></p> <ul> <li>Returns a transaction object to track upgrade operation progress</li> <li>Use the transaction ID or the entity UID to monitor the status of the upgrade</li> </ul>
 
+        :param msp_upgrade_ftd_devices_input: (required)
+        :type msp_upgrade_ftd_devices_input: MspUpgradeFtdDevicesInput
         :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
@@ -1800,6 +1808,7 @@ class MSPDeviceUpgradesApi:
         """ # noqa: E501
 
         _param = self._upgrade_msp_managed_ftd_devices_serialize(
+            msp_upgrade_ftd_devices_input=msp_upgrade_ftd_devices_input,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1824,6 +1833,7 @@ class MSPDeviceUpgradesApi:
     @validate_call
     def upgrade_msp_managed_ftd_devices_without_preload_content(
         self,
+        msp_upgrade_ftd_devices_input: MspUpgradeFtdDevicesInput,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1841,6 +1851,8 @@ class MSPDeviceUpgradesApi:
 
         <p>Asynchronous operation to upgrade multiple FTD devices across managed tenants.</p> <p><strong>Notes:</strong></p> <ul> <li>Maximum of 50 FTD devices per hardware model per managed tenant per request</li> </ul> <p><strong>Response:</strong></p> <ul> <li>Returns a transaction object to track upgrade operation progress</li> <li>Use the transaction ID or the entity UID to monitor the status of the upgrade</li> </ul>
 
+        :param msp_upgrade_ftd_devices_input: (required)
+        :type msp_upgrade_ftd_devices_input: MspUpgradeFtdDevicesInput
         :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
@@ -1864,6 +1876,7 @@ class MSPDeviceUpgradesApi:
         """ # noqa: E501
 
         _param = self._upgrade_msp_managed_ftd_devices_serialize(
+            msp_upgrade_ftd_devices_input=msp_upgrade_ftd_devices_input,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1883,6 +1896,7 @@ class MSPDeviceUpgradesApi:
 
     def _upgrade_msp_managed_ftd_devices_serialize(
         self,
+        msp_upgrade_ftd_devices_input,
         _request_auth,
         _content_type,
         _headers,
@@ -1906,6 +1920,8 @@ class MSPDeviceUpgradesApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if msp_upgrade_ftd_devices_input is not None:
+            _body_params = msp_upgrade_ftd_devices_input
 
 
         # set the HTTP header `Accept`
@@ -1915,6 +1931,19 @@ class MSPDeviceUpgradesApi:
             ]
         )
 
+        # 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_client.py

@@ -88,7 +88,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/1.15.371/python'
+        self.user_agent = 'OpenAPI-Generator/1.15.389/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

scc_firewall_manager_sdk/configuration.py

@@ -380,7 +380,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 1.15.0\n"\
-               "SDK Package Version: 1.15.371".\
+               "SDK Package Version: 1.15.389".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self):

scc_firewall_manager_sdk/models/__init__.py

@@ -76,6 +76,7 @@ from scc_firewall_manager_sdk.models.command_response import CommandResponse
 from scc_firewall_manager_sdk.models.common_api_error import CommonApiError
 from scc_firewall_manager_sdk.models.compatible_device_dto import CompatibleDeviceDto
 from scc_firewall_manager_sdk.models.compatible_version_info_dto import CompatibleVersionInfoDto
+from scc_firewall_manager_sdk.models.completion_status_dto import CompletionStatusDto
 from scc_firewall_manager_sdk.models.config_state import ConfigState
 from scc_firewall_manager_sdk.models.conflict_detection_interval import ConflictDetectionInterval
 from scc_firewall_manager_sdk.models.conflict_detection_state import ConflictDetectionState
@@ -190,6 +191,7 @@ from scc_firewall_manager_sdk.models.msp_managed_template_distinct_attribute_val
 from scc_firewall_manager_sdk.models.msp_managed_templates_page import MspManagedTemplatesPage
 from scc_firewall_manager_sdk.models.msp_managed_tenant import MspManagedTenant
 from scc_firewall_manager_sdk.models.msp_managed_tenant_page import MspManagedTenantPage
+from scc_firewall_manager_sdk.models.msp_upgrade_ftd_devices_input import MspUpgradeFtdDevicesInput
 from scc_firewall_manager_sdk.models.msp_upgrade_run_dto import MspUpgradeRunDto
 from scc_firewall_manager_sdk.models.msp_upgrade_run_dto_page import MspUpgradeRunDtoPage
 from scc_firewall_manager_sdk.models.msp_upgrade_runs_attribute_values import MspUpgradeRunsAttributeValues

scc_firewall_manager_sdk/models/cdo_transaction.py

@@ -29,18 +29,18 @@ class CdoTransaction(BaseModel):
     CdoTransaction
     """ # noqa: E501
     cancellable: Optional[StrictBool] = None
-    cdo_transaction_status: Optional[StrictStr] = Field(default=None, description="The status of the transaction", alias="cdoTransactionStatus")
-    entity_uid: Optional[StrictStr] = Field(default=None, description="The unique identifier of the entity that the transaction is triggered on. This can be empty, for a transaction that is not tied to an entity, such as transactions which refresh RA VPN sessions.", alias="entityUid")
-    entity_url: Optional[StrictStr] = Field(default=None, description="A URL to access the entity that the transaction is triggered on. This can also be empty", alias="entityUrl")
-    error_details: Optional[Dict[str, StrictStr]] = Field(default=None, description="Transaction error details, if any", alias="errorDetails")
-    error_message: Optional[StrictStr] = Field(default=None, description="Transaction error message, if any", alias="errorMessage")
-    last_updated_time: Optional[datetime] = Field(default=None, description="The time (UTC; represented using the RFC-3339 standard) at which the transaction status was last updated", alias="lastUpdatedTime")
-    submission_time: Optional[datetime] = Field(default=None, description="The time (UTC; represented using the RFC-3339 standard) at which the transaction was triggered", alias="submissionTime")
-    tenant_uid: Optional[StrictStr] = Field(default=None, description="The unique identifier of the tenant that the transaction triggered on.", alias="tenantUid")
-    transaction_details: Optional[Dict[str, StrictStr]] = Field(default=None, description="Transaction details, if any", alias="transactionDetails")
-    transaction_polling_url: Optional[StrictStr] = Field(default=None, description="The URL to poll to track the progress of the transaction.", alias="transactionPollingUrl")
-    transaction_type: Optional[StrictStr] = Field(default=None, description="the type of the transaction", alias="transactionType")
-    transaction_uid: Optional[StrictStr] = Field(default=None, description="The unique identifier of the transaction triggered.", alias="transactionUid")
+    cdo_transaction_status: Optional[StrictStr] = Field(default=None, description="Status of the transaction.", alias="cdoTransactionStatus")
+    entity_uid: Optional[StrictStr] = Field(default=None, description="Unique identifier of the entity that the transaction is triggered on. This can be empty, for a transaction that is not tied to an entity, such as transactions which refresh RA VPN sessions.", alias="entityUid")
+    entity_url: Optional[StrictStr] = Field(default=None, description="URL to access the entity that the transaction is triggered on. This can also be empty if not applicable.", alias="entityUrl")
+    error_details: Optional[Dict[str, StrictStr]] = Field(default=None, description="Transaction error details, if any.", alias="errorDetails")
+    error_message: Optional[StrictStr] = Field(default=None, description="Transaction error message, if any.", alias="errorMessage")
+    last_updated_time: Optional[datetime] = Field(default=None, description="Time (UTC; represented using the RFC-3339 standard) at which the transaction status was last updated.", alias="lastUpdatedTime")
+    submission_time: Optional[datetime] = Field(default=None, description="Time (UTC; represented using the RFC-3339 standard) at which the transaction was triggered.", alias="submissionTime")
+    tenant_uid: Optional[StrictStr] = Field(default=None, description="Unique identifier of the tenant that the transaction was triggered on.", alias="tenantUid")
+    transaction_details: Optional[Dict[str, StrictStr]] = Field(default=None, description="Transaction details, if any.", alias="transactionDetails")
+    transaction_polling_url: Optional[StrictStr] = Field(default=None, description="Polling URL to track the progress of the transaction.", alias="transactionPollingUrl")
+    transaction_type: Optional[StrictStr] = Field(default=None, description="Type of the transaction.", alias="transactionType")
+    transaction_uid: Optional[StrictStr] = Field(default=None, description="Unique identifier of the transaction triggered.", alias="transactionUid")
     __properties: ClassVar[List[str]] = ["cancellable", "cdoTransactionStatus", "entityUid", "entityUrl", "errorDetails", "errorMessage", "lastUpdatedTime", "submissionTime", "tenantUid", "transactionDetails", "transactionPollingUrl", "transactionType", "transactionUid"]
 
     @field_validator('cdo_transaction_status')

scc_firewall_manager_sdk/models/completion_status_dto.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.15.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompletionStatusDto(BaseModel):
+    """
+    CompletionStatusDto
+    """ # noqa: E501
+    message: Optional[StrictStr] = Field(default=None, description="A message, indicating current progress, returned from the device.")
+    name: Optional[StrictStr] = Field(default=None, description="The name of the device. Note: this will be the name of the node on the cdFMC if the device is part of an HA pair or cluster.")
+    node_type: Optional[StrictStr] = Field(default=None, description="(HA Pairs and clusters only) The node type of the device.", alias="nodeType")
+    percentage_complete: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The percentage completion of the current task being performed", alias="percentageComplete")
+    __properties: ClassVar[List[str]] = ["message", "name", "nodeType", "percentageComplete"]
+
+    @field_validator('node_type')
+    def node_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['HA_PRIMARY', 'HA_SECONDARY', 'CLUSTER_CONTROL', 'CLUSTER_DATA']):
+            raise ValueError("must be one of enum values ('HA_PRIMARY', 'HA_SECONDARY', 'CLUSTER_CONTROL', 'CLUSTER_DATA')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CompletionStatusDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompletionStatusDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message"),
+            "name": obj.get("name"),
+            "nodeType": obj.get("nodeType"),
+            "percentageComplete": obj.get("percentageComplete")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/device_upgrade_status_dto.py

@@ -18,8 +18,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional, Union
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.completion_status_dto import CompletionStatusDto
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,10 +28,9 @@ class DeviceUpgradeStatusDto(BaseModel):
     """
     DeviceUpgradeStatusDto
     """ # noqa: E501
-    message: Optional[StrictStr] = Field(default=None, description="A message, indicating current progress, returned from the device.")
-    percentage_complete: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The percentage completion of the current task being performed", alias="percentageComplete")
+    completion_statuses: Optional[List[CompletionStatusDto]] = Field(default=None, description="The completion status of the upgrade on the device. For HA pairs or clusters, there will be multiple completion statuses; one per node of the pair or cluster.", alias="completionStatuses")
     uid: Optional[StrictStr] = Field(default=None, description="The unique identifier, represented as a UUID, of the device in SCC Firewall Manager.")
-    __properties: ClassVar[List[str]] = ["message", "percentageComplete", "uid"]
+    __properties: ClassVar[List[str]] = ["completionStatuses", "uid"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -71,6 +71,13 @@ class DeviceUpgradeStatusDto(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of each item in completion_statuses (list)
+        _items = []
+        if self.completion_statuses:
+            for _item in self.completion_statuses:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['completionStatuses'] = _items
         return _dict
 
     @classmethod
@@ -83,8 +90,7 @@ class DeviceUpgradeStatusDto(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "message": obj.get("message"),
-            "percentageComplete": obj.get("percentageComplete"),
+            "completionStatuses": [CompletionStatusDto.from_dict(_item) for _item in obj["completionStatuses"]] if obj.get("completionStatuses") is not None else None,
             "uid": obj.get("uid")
         })
         return _obj

scc_firewall_manager_sdk/models/msp_upgrade_ftd_devices_input.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.15.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MspUpgradeFtdDevicesInput(BaseModel):
+    """
+    MspUpgradeFtdDevicesInput
+    """ # noqa: E501
+    device_uids: Annotated[List[StrictStr], Field(min_length=1)] = Field(description="Set of device unique identifiers (UUIDs) to upgrade in Security Cloud Control. All of the devices have to be managed by the MSSP portal, be of type CDFMC_MANAGED_FTD, have the connectivity state ONLINE, and be compatible with the software version specified.", alias="deviceUids")
+    ignore_maintenance_window: Optional[StrictBool] = Field(default=None, description="A boolean value, indicating whether devices maintenance window should be ignored. If this is set to true, upgrade will be allowed even if there are devices outside their maintenance window.", alias="ignoreMaintenanceWindow")
+    name: Optional[StrictStr] = Field(default=None, description="Specify a human-readable name for the upgrade run.")
+    software_version: Optional[StrictStr] = Field(default=None, description="Specify the software version to which all devices will be upgraded.", alias="softwareVersion")
+    stage_upgrade_only: Optional[StrictBool] = Field(default=False, description="A boolean value, indicating whether the upgrade should be staged. If set to true, the image will be downloaded onto the devices and readiness checks will be performed. However, the upgrade will not be applied to the devices.", alias="stageUpgradeOnly")
+    __properties: ClassVar[List[str]] = ["deviceUids", "ignoreMaintenanceWindow", "name", "softwareVersion", "stageUpgradeOnly"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MspUpgradeFtdDevicesInput from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MspUpgradeFtdDevicesInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "deviceUids": obj.get("deviceUids"),
+            "ignoreMaintenanceWindow": obj.get("ignoreMaintenanceWindow"),
+            "name": obj.get("name"),
+            "softwareVersion": obj.get("softwareVersion"),
+            "stageUpgradeOnly": obj.get("stageUpgradeOnly") if obj.get("stageUpgradeOnly") is not None else False
+        })
+        return _obj
+
+

{scc_firewall_manager_sdk-1.15.371.dist-info → scc_firewall_manager_sdk-1.15.389.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scc-firewall-manager-sdk
-Version: 1.15.371
+Version: 1.15.389
 Summary: Cisco Security Cloud Control Firewall Manager API
 Home-page: 
 Author: Cisco Security Cloud Control TAC

{scc_firewall_manager_sdk-1.15.371.dist-info → scc_firewall_manager_sdk-1.15.389.dist-info}/RECORD

@@ -1,7 +1,7 @@
-scc_firewall_manager_sdk/__init__.py,sha256=T6qKzxX8iRjXRVGqQgRWlLJD6uqlfwxW4tpecNS90pw,23696
-scc_firewall_manager_sdk/api_client.py,sha256=qsBpOKi4SdMW1JG_GnI3FnBw9VJaEDYRKg6VJgvT5ak,25921
+scc_firewall_manager_sdk/__init__.py,sha256=FZbOhFYnc8aj2KAVWi31Y0cjP706qE3GvicDUQy_z2Y,23882
+scc_firewall_manager_sdk/api_client.py,sha256=aY8qKTaVmIKmCS8bI6BNquYYbU-2YlU3GRyvUIc0FZs,25921
 scc_firewall_manager_sdk/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-scc_firewall_manager_sdk/configuration.py,sha256=1fmgwU_jjjtYzSgo-x7gsyVmQnkOjfau91whNJzx24A,15993
+scc_firewall_manager_sdk/configuration.py,sha256=Q-UQO2e7dyKwhKInvJTq4iu2N_wDS_8zITZ2EvuSF8c,15993
 scc_firewall_manager_sdk/exceptions.py,sha256=u5-7l5MRjP-aS2pNudBzqSw9OI4xVsIvUjw4WCA8LEk,6039
 scc_firewall_manager_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scc_firewall_manager_sdk/rest.py,sha256=cSeilvAB5y-V_10IdXcZ0kOyv5dYW8jeWVhrD6kUDa0,9309
@@ -9,21 +9,21 @@ scc_firewall_manager_sdk/api/__init__.py,sha256=4QyrZUVjEAjIDVynI9stPsUyDC8aFw3c
 scc_firewall_manager_sdk/api/ai_assistant_api.py,sha256=k4PXtChJD_MzAc5cn_EYtC1Q4YCCknDPTYhLlh4tFhA,60316
 scc_firewall_manager_sdk/api/asa_access_groups_api.py,sha256=n29L7dlwRpP8MsBlgMn9pSwV-uCXf5QHf18qiEXU4xY,60430
 scc_firewall_manager_sdk/api/asa_access_rules_api.py,sha256=zStpYuIiNHyTaIINPqu5qSSWp3-wGo9SmXodwEJEJhI,60377
-scc_firewall_manager_sdk/api/asa_interfaces_api.py,sha256=3i-LnJmWJWYL7ToH3vV7-SVV6rDaKgKxjI4hDdbbRcM,291786
+scc_firewall_manager_sdk/api/asa_interfaces_api.py,sha256=2zS6a-90RtlU8aNDa16k4F44KXimd2Tno7TTIW8tKSA,291498
 scc_firewall_manager_sdk/api/audit_logs_api.py,sha256=o3hgw44okxXzyeVcU05xiQgqML1D1HDIlAj6RbhWdSk,20506
 scc_firewall_manager_sdk/api/change_requests_api.py,sha256=zCdwKO8E5Jv_4cHGp8PT3Z9ZrqvkyhNN5VH2gWcoBps,48560
 scc_firewall_manager_sdk/api/changelogs_api.py,sha256=6C4ugk1SwLgJfCM-q-_H2gnNoWB7jYqhUhpIDSUbY-4,30875
 scc_firewall_manager_sdk/api/command_line_interface_api.py,sha256=_sUPKdTkBkXNbk5m9iGH1t-eYJbFdzDLjLAuNMWJqYc,110872
 scc_firewall_manager_sdk/api/commands_api.py,sha256=U1cDPCmUAgOPnCOC8KcbcQpLGSwgOBBgHUcKH6JmWK4,33891
 scc_firewall_manager_sdk/api/connectors_api.py,sha256=lw4asxJMtyHTm3sxM6Z7S1O2tbr4ZtbjVrZIalmYagI,59889
-scc_firewall_manager_sdk/api/device_health_aggregations_api.py,sha256=r4YyX6_HDWriUOh9dRFmjNzY08rozUatGOjpFzhkyJ4,29025
+scc_firewall_manager_sdk/api/device_health_aggregations_api.py,sha256=icgXVtuGS-Mr042eNBuzyNW-Y2sqNkEvmDm3vM1VJUw,29373
 scc_firewall_manager_sdk/api/device_health_api.py,sha256=UoxgUo10Am1kga8U0Kxhb6DDw6d7wpXxzGopsvUJ1JI,62283
-scc_firewall_manager_sdk/api/device_upgrades_api.py,sha256=nEtjWfCJ9eDVONZ0TLUApEcanm82CwcXTuax7kUVZxs,138514
+scc_firewall_manager_sdk/api/device_upgrades_api.py,sha256=7LcR01HoNtAijJEjCEkJjI2LuYnhD8eB2vzh73qjwRo,138466
 scc_firewall_manager_sdk/api/events_api.py,sha256=jYkPjWxnNwNYOk1P7kMBaSp2gpe_lI8WodaxIfUKdQM,15399
-scc_firewall_manager_sdk/api/interface_health_aggregations_api.py,sha256=2fxsrkfFpI2zSx3WnviJnP0uuS2XBT8YE_sZ0FcXjk0,40990
+scc_firewall_manager_sdk/api/interface_health_aggregations_api.py,sha256=_vzEX_XsiKLJIq6edOc0CMlGIr0henKiDS1-9KnAZHc,41338
 scc_firewall_manager_sdk/api/inventory_api.py,sha256=EJqDZzqBE4w_klxuo84rSYmrmbinGSJEbSbU6Wqs4Gg,444995
 scc_firewall_manager_sdk/api/meta_api.py,sha256=0T4mIpkOc0FyDIvEN5qhRQbKN4CzOM00_sRVY2oG59U,29963
-scc_firewall_manager_sdk/api/msp_device_upgrades_api.py,sha256=4aM0if2FEPAjwkSos46ge9IXJYZTajKEKmwHZyrH4vQ,83128
+scc_firewall_manager_sdk/api/msp_device_upgrades_api.py,sha256=rxCdALStZkyZRnglyNCo954iwvOuLUL2IH52CYa6aFM,84661
 scc_firewall_manager_sdk/api/msp_inventory_api.py,sha256=eLYqsv_7YNxQGLQLqEnWfSFPIJ8nWnuJQkZfxtGapxM,185473
 scc_firewall_manager_sdk/api/msp_tenant_management_api.py,sha256=OE4LcSCFrAoJ-eeDoFO8aGzqfvoWb3QIQZ73X_5rdH4,110542
 scc_firewall_manager_sdk/api/msp_user_management_api.py,sha256=MPy-WAv52ziuUcrK_Tq_q38PN1pbpgfL5fdqzYP81S8,54797
@@ -33,7 +33,7 @@ scc_firewall_manager_sdk/api/search_api.py,sha256=PonVl7RieSVsbCCVQOdqIA7vx2NCH5
 scc_firewall_manager_sdk/api/tenant_management_api.py,sha256=3PWPuirkaUck1VZex3w4Cg3qO05GF0f7xeiptaAc5zE,55069
 scc_firewall_manager_sdk/api/transactions_api.py,sha256=fz0Ko2bAXFpz0SM8psceOlcxq0gXnrnuTEhaX1E0QzA,23402
 scc_firewall_manager_sdk/api/users_api.py,sha256=MKuyXmxWLSqPBkfA7rUGZ1EO1Ox-Oge7QhhgzSFAVu8,191609
-scc_firewall_manager_sdk/models/__init__.py,sha256=EJrLv9-ouEiPPH5gvD03ByUnHhaoAsSVmXxg7XaJKGE,20958
+scc_firewall_manager_sdk/models/__init__.py,sha256=Nn0R0eMVAuTsTWqkFvj7HWUvhGTCiDkW2gE8uZ8kItE,21144
 scc_firewall_manager_sdk/models/access_group.py,sha256=9FlXrDT5xhtk-uWuwgMmM-qAGiKZrpfnkphZuogGsHo,4583
 scc_firewall_manager_sdk/models/access_group_create_input.py,sha256=7tgCifqvqbwS2bZvS_PQdIV_ra_jiEbupJhyaHcG8ys,3930
 scc_firewall_manager_sdk/models/access_group_page.py,sha256=imWa0te5qmTpXfuE8W8YM3SG01MIn4ewbA-_N8kPKHk,3725
@@ -77,7 +77,7 @@ scc_firewall_manager_sdk/models/cdo_cli_result_page.py,sha256=EEzs3R4dw2xL_DmFPg
 scc_firewall_manager_sdk/models/cdo_region.py,sha256=fwAiLYKyjGj_dDMLs-_8FPoupimXXltZoVElUoI20OQ,2995
 scc_firewall_manager_sdk/models/cdo_region_list.py,sha256=L3qMHaEdwsOmQ3PVzXs4MpliUwzQOY8It6el0WOGfKc,3059
 scc_firewall_manager_sdk/models/cdo_token_info.py,sha256=kWHp0Fc6Lkmd-9WuC--bCwKbyIoAdPqQHXUD5KeCPcU,4767
-scc_firewall_manager_sdk/models/cdo_transaction.py,sha256=iaoUzaGriNyMvwyy9SM1EZ2BGB5OcVNADd4FgnpofJ8,8893
+scc_firewall_manager_sdk/models/cdo_transaction.py,sha256=57IFTIhwEokTXmR5DjBHrLjUlo-1ZyiLzwilsYvDik4,8889
 scc_firewall_manager_sdk/models/change_request.py,sha256=pvjYq818o6W8Fy2_Rt6qMp7jSOFnCqK9goVIWPxENGY,2939
 scc_firewall_manager_sdk/models/change_request_create_input.py,sha256=VEEWpKGhmegCbIYkzhctJPjBpDQgzATuN9zbE2DjRTA,2961
 scc_firewall_manager_sdk/models/change_request_page.py,sha256=8OBeXBlutEbhpLVe1n6hhaVpFzAMX4MPtO8jGLjfS-E,3741
@@ -95,6 +95,7 @@ scc_firewall_manager_sdk/models/command_response.py,sha256=zIlZo87Znsc93TBUWAWpm
 scc_firewall_manager_sdk/models/common_api_error.py,sha256=akVAOg_1NtmytBN58TnFa1WES1-wSn125ek7cxyN93U,3722
 scc_firewall_manager_sdk/models/compatible_device_dto.py,sha256=iKYMgQHIWj70d45nC2k6CRfMk0qF7nhse_bZuCMrf3g,4099
 scc_firewall_manager_sdk/models/compatible_version_info_dto.py,sha256=fuv4bGtHukdzC10LLZhsm1CH_pDsjrK1mu13yQpQtfs,4524
+scc_firewall_manager_sdk/models/completion_status_dto.py,sha256=px4OzUa0wflM6VNy1pxgQLm0qJTiMzKZiFiDcE01mdQ,3877
 scc_firewall_manager_sdk/models/config_state.py,sha256=4ThYVdFgktHjHnki-J1iasHvW2LRRStcGrLJAtjl0eE,873
 scc_firewall_manager_sdk/models/conflict_detection_interval.py,sha256=HUeSSF-fnKlddq_AtRYAiw4u2fmdh1SliZBqIWYlxew,957
 scc_firewall_manager_sdk/models/conflict_detection_state.py,sha256=BrUVNTXo6N2td50eMOvLCmj7GvO1CFvcLj1kep09ES4,880
@@ -119,7 +120,7 @@ scc_firewall_manager_sdk/models/device_metadata.py,sha256=PNCBkG35enpJhcwqiku4NH
 scc_firewall_manager_sdk/models/device_page.py,sha256=ha32rLEnC9v8JpDff_07t_rtFLa-pAJFelG7czmFl8g,3684
 scc_firewall_manager_sdk/models/device_patch_input.py,sha256=1LOG---DhQRxRYP0qA8PzzopCUX5c0bbLu7ptIySYXo,4224
 scc_firewall_manager_sdk/models/device_role.py,sha256=cqv0xYyNhsvAOoDRUpdeSwkbEE9u89hEf8gA66cAteQ,1038
-scc_firewall_manager_sdk/models/device_upgrade_status_dto.py,sha256=APBrvjPIxnDTUDPSsQBttDpwyTjqC77b0opzJ32A6ZY,3216
+scc_firewall_manager_sdk/models/device_upgrade_status_dto.py,sha256=m-mt_9DP77Tm3d1dzLKvpD4BMaXUrBqzgDa2eUDy0Ng,3629
 scc_firewall_manager_sdk/models/devices_patch_input.py,sha256=lSH-tNHYdS0CjWsHcSsnzQ9kL5ZxIsaVoHMxp5_Z8n4,3836
 scc_firewall_manager_sdk/models/disk_health_metrics.py,sha256=QU7XHLFoitOo4_ijLYromfp0stM8c7tx1T20uocXGXs,2947
 scc_firewall_manager_sdk/models/domain_settings.py,sha256=QqPTLHlNLd-PDoVqviIrU0IIPXhqLdTqTokV6uVQ8ug,3852
@@ -209,6 +210,7 @@ scc_firewall_manager_sdk/models/msp_managed_template_distinct_attribute_values.p
 scc_firewall_manager_sdk/models/msp_managed_templates_page.py,sha256=gtzwQeg0bEFDWbMDM4uBt-L4aYpp3hotFur4mdYZX1s,3786
 scc_firewall_manager_sdk/models/msp_managed_tenant.py,sha256=TNe2ICfaX9ZvueCjSovGdNDoTW6L9b6gIcrY4l3MlJI,3784
 scc_firewall_manager_sdk/models/msp_managed_tenant_page.py,sha256=eMkOCp0F3rSPYEYWxOMm99QIhLkPxj26-OM77nyWOKc,3766
+scc_firewall_manager_sdk/models/msp_upgrade_ftd_devices_input.py,sha256=-CgOY7Ju_wypfERMPR3Fi_Uo8UsZdR0sVfqTbhFAmms,4312
 scc_firewall_manager_sdk/models/msp_upgrade_run_dto.py,sha256=43fIdsW4UY-xKZ4TnIkTXdMSj99Db-ahwQfBgb5klk0,6821
 scc_firewall_manager_sdk/models/msp_upgrade_run_dto_page.py,sha256=eE2zAYd6zeQ3aSP4GfYjJMFRvID6LzWAkBih_H3Gp9A,3767
 scc_firewall_manager_sdk/models/msp_upgrade_runs_attribute_values.py,sha256=S-tiVbwfK92uqJTN5-pis5IxZrXQbnhUjDldHzmXU0Q,4414
@@ -284,7 +286,7 @@ scc_firewall_manager_sdk/models/vlan_interface_create_input.py,sha256=AKUqPJw5ku
 scc_firewall_manager_sdk/models/vlan_interface_patch_input.py,sha256=srEFTyQykscNrWsbp8KGEzbmHC07_AU3DXjJ-7Be4zc,6054
 scc_firewall_manager_sdk/models/ztp_onboarding_input.py,sha256=HAgBTdocZeHGDZP_-9NyRtzP9E7BReGtiOmn4S3J-_g,5326
 scc_firewall_manager_sdk/models/ztp_onboarding_template_configuration.py,sha256=f9Z62yGFvz4QAQ07Z4bjfHLw2bRg46ccwoLuQ8q30TE,4808
-scc_firewall_manager_sdk-1.15.371.dist-info/METADATA,sha256=dQ7LJKXMcvaRqXI4kuH3Aid6hYSMYDc33GWP-AYzjS8,596
-scc_firewall_manager_sdk-1.15.371.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-scc_firewall_manager_sdk-1.15.371.dist-info/top_level.txt,sha256=_g9WfFWGagKs6ULdfhEt8e7RXknpcp9_jA9ubIL4U3I,25
-scc_firewall_manager_sdk-1.15.371.dist-info/RECORD,,
+scc_firewall_manager_sdk-1.15.389.dist-info/METADATA,sha256=vSepCni3D73eZCFDem52VrKPRPRuISFjdvEJ8HlM0hc,596
+scc_firewall_manager_sdk-1.15.389.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+scc_firewall_manager_sdk-1.15.389.dist-info/top_level.txt,sha256=_g9WfFWGagKs6ULdfhEt8e7RXknpcp9_jA9ubIL4U3I,25
+scc_firewall_manager_sdk-1.15.389.dist-info/RECORD,,