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

scc_firewall_manager_sdk/models/device_license_page.py

@@ -0,0 +1,102 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.device_license_dto import DeviceLicenseDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceLicensePage(BaseModel):
+    """
+    DeviceLicensePage
+    """ # noqa: E501
+    count: Optional[StrictInt] = Field(default=None, description="The total number of results available.")
+    items: Optional[List[DeviceLicenseDto]] = Field(default=None, description="The list of items retrieved.")
+    limit: Optional[StrictInt] = Field(default=None, description="The number of results retrieved.")
+    offset: Optional[StrictInt] = Field(default=None, 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.")
+    __properties: ClassVar[List[str]] = ["count", "items", "limit", "offset"]
+
+    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 DeviceLicensePage 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 each item in items (list)
+        _items = []
+        if self.items:
+            for _item in self.items:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DeviceLicensePage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "count": obj.get("count"),
+            "items": [DeviceLicenseDto.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
+            "limit": obj.get("limit"),
+            "offset": obj.get("offset")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/{tenant_ftd_compatibility_version.py → device_upgrade_status_dto.py}

@@ -20,19 +20,17 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from scc_firewall_manager_sdk.models.ftd_version import FtdVersion
+from scc_firewall_manager_sdk.models.completion_status_dto import CompletionStatusDto
 from typing import Optional, Set
 from typing_extensions import Self
 
-class TenantFtdCompatibilityVersion(BaseModel):
+class DeviceUpgradeStatusDto(BaseModel):
     """
-    TenantFtdCompatibilityVersion
+    DeviceUpgradeStatusDto
     """ # noqa: E501
-    compatible_ftd_versions: Optional[List[FtdVersion]] = Field(default=None, alias="compatibleFtdVersions")
-    device_uids: Optional[List[StrictStr]] = Field(default=None, alias="deviceUids")
-    hardware_model: Optional[StrictStr] = Field(default=None, alias="hardwareModel")
-    managed_tenant_uid: Optional[StrictStr] = Field(default=None, alias="managedTenantUid")
-    __properties: ClassVar[List[str]] = ["compatibleFtdVersions", "deviceUids", "hardwareModel", "managedTenantUid"]
+    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]] = ["completionStatuses", "uid"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -52,7 +50,7 @@ class TenantFtdCompatibilityVersion(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of TenantFtdCompatibilityVersion from a JSON string"""
+        """Create an instance of DeviceUpgradeStatusDto from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -73,18 +71,18 @@ class TenantFtdCompatibilityVersion(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in compatible_ftd_versions (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in completion_statuses (list)
         _items = []
-        if self.compatible_ftd_versions:
-            for _item in self.compatible_ftd_versions:
+        if self.completion_statuses:
+            for _item in self.completion_statuses:
                 if _item:
                     _items.append(_item.to_dict())
-            _dict['compatibleFtdVersions'] = _items
+            _dict['completionStatuses'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TenantFtdCompatibilityVersion from a dict"""
+        """Create an instance of DeviceUpgradeStatusDto from a dict"""
         if obj is None:
             return None
 
@@ -92,10 +90,8 @@ class TenantFtdCompatibilityVersion(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "compatibleFtdVersions": [FtdVersion.from_dict(_item) for _item in obj["compatibleFtdVersions"]] if obj.get("compatibleFtdVersions") is not None else None,
-            "deviceUids": obj.get("deviceUids"),
-            "hardwareModel": obj.get("hardwareModel"),
-            "managedTenantUid": obj.get("managedTenantUid")
+            "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/enable_cd_fmc_for_tenant_request.py

@@ -0,0 +1,88 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EnableCdFmcForTenantRequest(BaseModel):
+    """
+    EnableCdFmcForTenantRequest
+    """ # noqa: E501
+    dedicated_cd_fmc_instance: StrictBool = Field(alias="dedicatedCdFmcInstance")
+    __properties: ClassVar[List[str]] = ["dedicatedCdFmcInstance"]
+
+    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 EnableCdFmcForTenantRequest 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 EnableCdFmcForTenantRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dedicatedCdFmcInstance": obj.get("dedicatedCdFmcInstance")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/log_settings.py

@@ -28,7 +28,7 @@ class LogSettings(BaseModel):
     LogSettings
     """ # noqa: E501
     interval: Optional[StrictInt] = Field(default=None, description="The interval")
-    level: StrictStr = Field(description="The level")
+    level: Optional[StrictStr] = Field(default=None, description="The level")
     __properties: ClassVar[List[str]] = ["interval", "level"]
 
     model_config = ConfigDict(

scc_firewall_manager_sdk/models/metric_aggregation_list_item.py

@@ -18,8 +18,8 @@ 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 typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,11 +29,13 @@ class MetricAggregationListItem(BaseModel):
     """ # noqa: E501
     device_name: Optional[StrictStr] = Field(default=None, alias="deviceName")
     device_uid: Optional[StrictStr] = Field(default=None, alias="deviceUid")
-    managed_tenant_name: Optional[StrictStr] = Field(default=None, alias="managedTenantName")
-    managed_tenant_uid: Optional[StrictStr] = Field(default=None, alias="managedTenantUid")
+    interface_name: Optional[StrictStr] = Field(default=None, alias="interfaceName")
+    interface_uid: Optional[StrictStr] = Field(default=None, alias="interfaceUid")
     metric: Optional[StrictStr] = None
-    value: Optional[Union[StrictFloat, StrictInt]] = None
-    __properties: ClassVar[List[str]] = ["deviceName", "deviceUid", "managedTenantName", "managedTenantUid", "metric", "value"]
+    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
+    tenant_uid: Optional[StrictStr] = Field(default=None, alias="tenantUid")
+    value: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["deviceName", "deviceUid", "interfaceName", "interfaceUid", "metric", "tenantName", "tenantUid", "value"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -88,9 +90,11 @@ class MetricAggregationListItem(BaseModel):
         _obj = cls.model_validate({
             "deviceName": obj.get("deviceName"),
             "deviceUid": obj.get("deviceUid"),
-            "managedTenantName": obj.get("managedTenantName"),
-            "managedTenantUid": obj.get("managedTenantUid"),
+            "interfaceName": obj.get("interfaceName"),
+            "interfaceUid": obj.get("interfaceUid"),
             "metric": obj.get("metric"),
+            "tenantName": obj.get("tenantName"),
+            "tenantUid": obj.get("tenantUid"),
             "value": obj.get("value")
         })
         return _obj

scc_firewall_manager_sdk/models/msp_calculate_compatible_upgrade_versions_input.py

@@ -0,0 +1,89 @@
+# 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, 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 MspCalculateCompatibleUpgradeVersionsInput(BaseModel):
+    """
+    List of unique identifiers, represented as UUIDs, of the devices in Security Cloud Control. Note that all the specified devices must be in tenants managed by the MSP portal.
+    """ # noqa: E501
+    device_uids: Optional[Annotated[List[StrictStr], Field(min_length=1, max_length=50)]] = Field(default=None, description="The list of devices to calculate compatible upgrade versions for. All of the devices must exist, be associated with the managed tenant, and be in the connectivity state 'ONLINE'.", alias="deviceUids")
+    __properties: ClassVar[List[str]] = ["deviceUids"]
+
+    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 MspCalculateCompatibleUpgradeVersionsInput 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 MspCalculateCompatibleUpgradeVersionsInput 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")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/msp_managed_device.py

@@ -26,7 +26,9 @@ from scc_firewall_manager_sdk.models.asa_failover_mode import AsaFailoverMode
 from scc_firewall_manager_sdk.models.config_state import ConfigState
 from scc_firewall_manager_sdk.models.conflict_detection_state import ConflictDetectionState
 from scc_firewall_manager_sdk.models.connectivity_state import ConnectivityState
+from scc_firewall_manager_sdk.models.device_maintenance_window import DeviceMaintenanceWindow
 from scc_firewall_manager_sdk.models.entity_type import EntityType
+from scc_firewall_manager_sdk.models.fmc_device_record import FmcDeviceRecord
 from scc_firewall_manager_sdk.models.ftd_cluster_info import FtdClusterInfo
 from scc_firewall_manager_sdk.models.ftd_ha_info import FtdHaInfo
 from scc_firewall_manager_sdk.models.labels import Labels
@@ -46,6 +48,8 @@ class MspManagedDevice(BaseModel):
     config_state: Optional[ConfigState] = Field(default=None, alias="configState")
     conflict_detection_state: Optional[ConflictDetectionState] = Field(default=None, alias="conflictDetectionState")
     connectivity_state: Optional[ConnectivityState] = Field(default=None, alias="connectivityState")
+    device_maintenance_window: Optional[DeviceMaintenanceWindow] = Field(default=None, alias="deviceMaintenanceWindow")
+    device_record_on_fmc: Optional[FmcDeviceRecord] = Field(default=None, alias="deviceRecordOnFmc")
     device_type: Optional[EntityType] = Field(default=None, alias="deviceType")
     ftd_cluster_info: Optional[FtdClusterInfo] = Field(default=None, alias="ftdClusterInfo")
     ftd_ha_info: Optional[FtdHaInfo] = Field(default=None, alias="ftdHaInfo")
@@ -63,7 +67,7 @@ class MspManagedDevice(BaseModel):
     software_version: Optional[StrictStr] = Field(default=None, description="The version of the software running on the device.", alias="softwareVersion")
     tenant_uid: Optional[StrictStr] = Field(default=None, alias="tenantUid")
     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]] = ["address", "asaFailoverMate", "asaFailoverMode", "asaFailoverState", "certificateExpiryDate", "chassisSerial", "configState", "conflictDetectionState", "connectivityState", "deviceType", "ftdClusterInfo", "ftdHaInfo", "hardwareModel", "labels", "managedTenantDisplayName", "managedTenantName", "managedTenantRegion", "managedTenantUid", "modelNumber", "name", "raVpnCertificateExpiryDate", "redundancyMode", "serial", "softwareVersion", "tenantUid", "uid"]
+    __properties: ClassVar[List[str]] = ["address", "asaFailoverMate", "asaFailoverMode", "asaFailoverState", "certificateExpiryDate", "chassisSerial", "configState", "conflictDetectionState", "connectivityState", "deviceMaintenanceWindow", "deviceRecordOnFmc", "deviceType", "ftdClusterInfo", "ftdHaInfo", "hardwareModel", "labels", "managedTenantDisplayName", "managedTenantName", "managedTenantRegion", "managedTenantUid", "modelNumber", "name", "raVpnCertificateExpiryDate", "redundancyMode", "serial", "softwareVersion", "tenantUid", "uid"]
 
     @field_validator('redundancy_mode')
     def redundancy_mode_validate_enum(cls, value):
@@ -117,6 +121,12 @@ class MspManagedDevice(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of asa_failover_mate
         if self.asa_failover_mate:
             _dict['asaFailoverMate'] = self.asa_failover_mate.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of device_maintenance_window
+        if self.device_maintenance_window:
+            _dict['deviceMaintenanceWindow'] = self.device_maintenance_window.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of device_record_on_fmc
+        if self.device_record_on_fmc:
+            _dict['deviceRecordOnFmc'] = self.device_record_on_fmc.to_dict()
         # override the default output from pydantic by calling `to_dict()` of ftd_cluster_info
         if self.ftd_cluster_info:
             _dict['ftdClusterInfo'] = self.ftd_cluster_info.to_dict()
@@ -147,6 +157,8 @@ class MspManagedDevice(BaseModel):
             "configState": obj.get("configState"),
             "conflictDetectionState": obj.get("conflictDetectionState"),
             "connectivityState": obj.get("connectivityState"),
+            "deviceMaintenanceWindow": DeviceMaintenanceWindow.from_dict(obj["deviceMaintenanceWindow"]) if obj.get("deviceMaintenanceWindow") is not None else None,
+            "deviceRecordOnFmc": FmcDeviceRecord.from_dict(obj["deviceRecordOnFmc"]) if obj.get("deviceRecordOnFmc") is not None else None,
             "deviceType": obj.get("deviceType"),
             "ftdClusterInfo": FtdClusterInfo.from_dict(obj["ftdClusterInfo"]) if obj.get("ftdClusterInfo") is not None else None,
             "ftdHaInfo": FtdHaInfo.from_dict(obj["ftdHaInfo"]) if obj.get("ftdHaInfo") is not None else None,

scc_firewall_manager_sdk/models/msp_managed_device_distinct_attribute_values.py

@@ -35,11 +35,13 @@ class MspManagedDeviceDistinctAttributeValues(BaseModel):
     conflict_detection_states: Optional[List[ConflictDetectionState]] = Field(default=None, description="The distinct conflict detection states for the devices managed by the MSP Portal.", alias="conflictDetectionStates")
     connectivity_states: Optional[List[ConnectivityState]] = Field(default=None, description="The distinct connectivity states for the devices managed by the MSP Portal.", alias="connectivityStates")
     device_types: Optional[List[EntityType]] = Field(default=None, description="The distinct device types for the devices managed by the MSP Portal.", alias="deviceTypes")
+    hardware_models: Optional[List[StrictStr]] = Field(default=None, description="The distinct hardware models for the devices managed by the MSP Portal.", alias="hardwareModels")
     managed_tenant_display_names: Optional[List[StrictStr]] = Field(default=None, description="The display names of the tenants that have devices onboarded and are managed by the MSP Portal.", alias="managedTenantDisplayNames")
     managed_tenant_names: Optional[List[StrictStr]] = Field(default=None, description="The names of the tenants that have devices onboarded and are managed by the MSP Portal.", alias="managedTenantNames")
+    model_numbers: Optional[List[StrictStr]] = Field(default=None, description="The distinct model numbers for the devices managed by the MSP Portal.", alias="modelNumbers")
     redundancy_modes: Optional[List[StrictStr]] = Field(default=None, description="The distinct redundancy modes for the devices managed by the MSP Portal.", alias="redundancyModes")
     software_versions: Optional[Dict[str, List[StrictStr]]] = Field(default=None, description="The software versions of the devices managed by the MSP Portal.", alias="softwareVersions")
-    __properties: ClassVar[List[str]] = ["configStates", "conflictDetectionStates", "connectivityStates", "deviceTypes", "managedTenantDisplayNames", "managedTenantNames", "redundancyModes", "softwareVersions"]
+    __properties: ClassVar[List[str]] = ["configStates", "conflictDetectionStates", "connectivityStates", "deviceTypes", "hardwareModels", "managedTenantDisplayNames", "managedTenantNames", "modelNumbers", "redundancyModes", "softwareVersions"]
 
     @field_validator('redundancy_modes')
     def redundancy_modes_validate_enum(cls, value):
@@ -107,8 +109,10 @@ class MspManagedDeviceDistinctAttributeValues(BaseModel):
             "conflictDetectionStates": obj.get("conflictDetectionStates"),
             "connectivityStates": obj.get("connectivityStates"),
             "deviceTypes": obj.get("deviceTypes"),
+            "hardwareModels": obj.get("hardwareModels"),
             "managedTenantDisplayNames": obj.get("managedTenantDisplayNames"),
             "managedTenantNames": obj.get("managedTenantNames"),
+            "modelNumbers": obj.get("modelNumbers"),
             "redundancyModes": obj.get("redundancyModes"),
             "softwareVersions": obj.get("softwareVersions")
         })

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="    <p>List of device identifiers to upgrade in Security Cloud Control.</p>     <p>Each entry must meet all of the following:</p>     <ul>       <li>The identifier is a UUID (unique identifier).</li>       <li>The device is managed by the MSSP portal.</li>       <li>The device type is <code>CDFMC_MANAGED_FTD</code>.</li>       <li>The connectivity state is <code>ONLINE</code>.</li>       <li>The device is compatible with the specified software version.</li>     </ul> ", alias="deviceUids")
+    ignore_maintenance_window: Optional[StrictBool] = Field(default=None, description="    <p>A boolean flag that determines whether device maintenance windows should be ignored during a full upgrade.</p>     <ul>       <li>If <code>stageUpgradeOnly</code> is set to <code>false</code>, this field is ignored.</li>       <li>If <code>stageUpgradeOnly</code> is <code>true</code> and this field is set to <code>false</code> (the default), the upgrade will fail if any selected device is outside its maintenance window.</li>     </ul> ", 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
+
+