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

scc_firewall_manager_sdk/api/users_api.py

@@ -2329,8 +2329,8 @@ class UsersApi:
     @validate_call
     def get_active_directory_groups(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -2349,9 +2349,9 @@ class UsersApi:
 
         Get a list of active directory groups associated with the Security Cloud Control tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -2408,8 +2408,8 @@ class UsersApi:
     @validate_call
     def get_active_directory_groups_with_http_info(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -2428,9 +2428,9 @@ class UsersApi:
 
         Get a list of active directory groups associated with the Security Cloud Control tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -2487,8 +2487,8 @@ class UsersApi:
     @validate_call
     def get_active_directory_groups_without_preload_content(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -2507,9 +2507,9 @@ class UsersApi:
 
         Get a list of active directory groups associated with the Security Cloud Control tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -2635,8 +2635,8 @@ class UsersApi:
     @validate_call
     def get_api_only_users(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -2655,9 +2655,9 @@ class UsersApi:
 
         Get a list of API-only users associated with the Security Cloud Control Firewall Manager tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -2714,8 +2714,8 @@ class UsersApi:
     @validate_call
     def get_api_only_users_with_http_info(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -2734,9 +2734,9 @@ class UsersApi:
 
         Get a list of API-only users associated with the Security Cloud Control Firewall Manager tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -2793,8 +2793,8 @@ class UsersApi:
     @validate_call
     def get_api_only_users_without_preload_content(
         self,
-        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The number of results to retrieve.")] = None,
-        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
+        limit: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Number of results to retrieve.")] = None,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -2813,9 +2813,9 @@ class UsersApi:
 
         Get a list of API-only users associated with the Security Cloud Control Firewall Manager tenant.
 
-        :param limit: The number of results to retrieve.
+        :param limit: Number of results to retrieve.
         :type limit: str
-        :param offset: The offset of the results retrieved. The Security Cloud Control API uses the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
+        :param offset: Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.
         :type offset: str
         :param q: The query to execute. Use the Lucene Query Syntax to construct your query.
         :type q: str
@@ -3464,7 +3464,7 @@ class UsersApi:
     def get_users(
         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,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -3485,7 +3485,7 @@ class UsersApi:
 
         :param limit: The 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
@@ -3543,7 +3543,7 @@ class UsersApi:
     def get_users_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,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -3564,7 +3564,7 @@ class UsersApi:
 
         :param limit: The 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
@@ -3622,7 +3622,7 @@ class UsersApi:
     def get_users_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,
+        offset: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Offset of the results retrieved. The Security Cloud Control APIs use the offset field to determine the index of the first result retrieved, and will retrieve `limit` results from the offset specified.")] = None,
         q: Annotated[Optional[StrictStr], Field(description="The query to execute. Use the Lucene Query Syntax to construct your query.")] = None,
         _request_timeout: Union[
             None,
@@ -3643,7 +3643,7 @@ class UsersApi:
 
         :param limit: The 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_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.287/python'
+        self.user_agent = 'OpenAPI-Generator/1.15.563/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.287".\
+               "SDK Package Version: 1.15.563".\
                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
@@ -94,6 +95,8 @@ from scc_firewall_manager_sdk.models.device_end_of_life_device_info import Devic
 from scc_firewall_manager_sdk.models.device_end_of_life_recommendation import DeviceEndOfLifeRecommendation
 from scc_firewall_manager_sdk.models.device_end_of_life_report import DeviceEndOfLifeReport
 from scc_firewall_manager_sdk.models.device_gateway_api_request import DeviceGatewayApiRequest
+from scc_firewall_manager_sdk.models.device_license_dto import DeviceLicenseDto
+from scc_firewall_manager_sdk.models.device_license_page import DeviceLicensePage
 from scc_firewall_manager_sdk.models.device_maintenance_window import DeviceMaintenanceWindow
 from scc_firewall_manager_sdk.models.device_manager_patch_input import DeviceManagerPatchInput
 from scc_firewall_manager_sdk.models.device_metadata import DeviceMetadata
@@ -107,6 +110,7 @@ from scc_firewall_manager_sdk.models.domain_settings import DomainSettings
 from scc_firewall_manager_sdk.models.duo_admin_panel_create_or_update_input import DuoAdminPanelCreateOrUpdateInput
 from scc_firewall_manager_sdk.models.duplex_type import DuplexType
 from scc_firewall_manager_sdk.models.duplicate_group_dto import DuplicateGroupDto
+from scc_firewall_manager_sdk.models.enable_cd_fmc_for_tenant_request import EnableCdFmcForTenantRequest
 from scc_firewall_manager_sdk.models.entity import Entity
 from scc_firewall_manager_sdk.models.entity_type import EntityType
 from scc_firewall_manager_sdk.models.ether_channel_interface_create_input import EtherChannelInterfaceCreateInput
@@ -189,6 +193,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
@@ -223,6 +228,7 @@ from scc_firewall_manager_sdk.models.service_object_content import ServiceObject
 from scc_firewall_manager_sdk.models.service_object_value_content import ServiceObjectValueContent
 from scc_firewall_manager_sdk.models.shared_object_value import SharedObjectValue
 from scc_firewall_manager_sdk.models.single_content import SingleContent
+from scc_firewall_manager_sdk.models.smart_account import SmartAccount
 from scc_firewall_manager_sdk.models.source_destination_ports_value import SourceDestinationPortsValue
 from scc_firewall_manager_sdk.models.source_dynamic_object_content import SourceDynamicObjectContent
 from scc_firewall_manager_sdk.models.source_network_content import SourceNetworkContent

scc_firewall_manager_sdk/models/access_group.py

@@ -34,7 +34,7 @@ class AccessGroup(BaseModel):
     is_shared: Optional[StrictBool] = Field(default=None, description="The flag that identifies if access group is shared.", alias="isShared")
     name: StrictStr = Field(description="The name of Access Group. Access Group names are unique in Security Cloud Control.")
     resources: Optional[List[Dict[str, Any]]] = Field(default=None, description="The set of of interface and direction pairs or global resource.")
-    shared_access_group_uid: StrictStr = Field(description="The unique identifier, represented as a UUID, of the shared access group manager associated with the Access Group.", alias="sharedAccessGroupUid")
+    shared_access_group_uid: Optional[StrictStr] = Field(default=None, description="The unique identifier, represented as a UUID, of the shared access group manager associated with the Access Group.", alias="sharedAccessGroupUid")
     uid: StrictStr = Field(description="The unique identifier, represented as a UUID, of Access Group in Security Cloud Control.")
     updated_date: Optional[datetime] = Field(default=None, description="The time (in UTC) at which Access Group was updated, represented using the RFC-3339 standard.", alias="updatedDate")
     __properties: ClassVar[List[str]] = ["appliedTo", "createdDate", "entityUid", "isShared", "name", "resources", "sharedAccessGroupUid", "uid", "updatedDate"]

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 be empty, for a transaction that is not tied to an entity, such as transactions which refresh RA VPN sessions.", 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/common_api_error.py

@@ -27,9 +27,9 @@ class CommonApiError(BaseModel):
     """
     CommonApiError
     """ # noqa: E501
-    details: Optional[Dict[str, Dict[str, Any]]] = Field(default=None, description="Additional details, if any, on the error")
-    error_code: Optional[StrictStr] = Field(default=None, description="A unique code that describes the error.", alias="errorCode")
-    error_msg: Optional[StrictStr] = Field(default=None, description="A human-readable error description in English.", alias="errorMsg")
+    details: Optional[Dict[str, Dict[str, Any]]] = Field(default=None, description="Additional details, if any, about the error.")
+    error_code: Optional[StrictStr] = Field(default=None, description="Unique code that describes the error.", alias="errorCode")
+    error_msg: Optional[StrictStr] = Field(default=None, description="Human-readable error description in English.", alias="errorMsg")
     __properties: ClassVar[List[str]] = ["details", "errorCode", "errorMsg"]
 
     @field_validator('error_code')

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_license_dto.py

@@ -0,0 +1,133 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.entity_type import EntityType
+from scc_firewall_manager_sdk.models.smart_account import SmartAccount
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceLicenseDto(BaseModel):
+    """
+    DeviceLicenseDto
+    """ # noqa: E501
+    compliance_status: Optional[StrictStr] = Field(default=None, description="Indicates whether the license used on the device is currently compliant with Smart Licensing restrictions.", alias="complianceStatus")
+    device_type: Optional[EntityType] = Field(default=None, alias="deviceType")
+    is_evaluation_license_expired: Optional[StrictBool] = Field(default=None, description="Indicates if the evaluation license has expired. This field is only relevant if the license status is EVALUATION.", alias="isEvaluationLicenseExpired")
+    is_export_control_features_allowed: Optional[StrictBool] = Field(default=None, description="Indicates if the license enables the device to offer export-controlled functionality. If this is set to false, Cisco software features that are subject to national security, foreign policy, and anti-terrorism laws and regulations are disabled.", alias="isExportControlFeaturesAllowed")
+    license_status: Optional[StrictStr] = Field(default=None, description="The license status of the device.", alias="licenseStatus")
+    licenses: Optional[List[StrictStr]] = Field(default=None, description="The list of licenses enabled on the device.")
+    model_number: Optional[StrictStr] = Field(default=None, description="The hardware, or virtualized hardware platform, that the device is running on (ASA-only). This field can be missing in the case of a partially onboarded device.", alias="modelNumber")
+    name: Optional[StrictStr] = Field(default=None, description="The name of the device in CDO. Device names are unique in Security Cloud Control.")
+    serial: Optional[StrictStr] = Field(default=None, description="The serial number of the device.")
+    smart_account: Optional[SmartAccount] = Field(default=None, alias="smartAccount")
+    uid: Optional[StrictStr] = Field(default=None, description="The unique identifier, represented as a UUID, of the device in Security Cloud Control.")
+    __properties: ClassVar[List[str]] = ["complianceStatus", "deviceType", "isEvaluationLicenseExpired", "isExportControlFeaturesAllowed", "licenseStatus", "licenses", "modelNumber", "name", "serial", "smartAccount", "uid"]
+
+    @field_validator('compliance_status')
+    def compliance_status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['IN_COMPLIANCE', 'OUT_OF_COMPLIANCE']):
+            raise ValueError("must be one of enum values ('IN_COMPLIANCE', 'OUT_OF_COMPLIANCE')")
+        return value
+
+    @field_validator('license_status')
+    def license_status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['LICENSED', 'UNLICENSED', 'EVALUATION']):
+            raise ValueError("must be one of enum values ('LICENSED', 'UNLICENSED', 'EVALUATION')")
+        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 DeviceLicenseDto 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of smart_account
+        if self.smart_account:
+            _dict['smartAccount'] = self.smart_account.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DeviceLicenseDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "complianceStatus": obj.get("complianceStatus"),
+            "deviceType": obj.get("deviceType"),
+            "isEvaluationLicenseExpired": obj.get("isEvaluationLicenseExpired"),
+            "isExportControlFeaturesAllowed": obj.get("isExportControlFeaturesAllowed"),
+            "licenseStatus": obj.get("licenseStatus"),
+            "licenses": obj.get("licenses"),
+            "modelNumber": obj.get("modelNumber"),
+            "name": obj.get("name"),
+            "serial": obj.get("serial"),
+            "smartAccount": SmartAccount.from_dict(obj["smartAccount"]) if obj.get("smartAccount") is not None else None,
+            "uid": obj.get("uid")
+        })
+        return _obj
+
+