catalystwan 0.41.2__py3-none-any.whl → 0.41.2.dev0__py3-none-any.whl

catalystwan/models/policy/policy_list.py

@@ -1,49 +1,60 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 import datetime
-from typing import List, Optional, Protocol
+from typing import Any, List, Optional
 from uuid import UUID
 
 from pydantic import BaseModel, Field
 
-from catalystwan.models.policy import AnyPolicyList
-from catalystwan.typed_list import DataSequence
+
+class PolicyListBase(BaseModel):
+    name: str = Field(
+        pattern="^[a-zA-Z0-9._-]{1,32}$",
+        description="Can include only alpha-numeric characters, "
+        "dot '.' or hyphen '-' or underscore '_'; maximum 32 characters",
+    )
+    description: Optional[str] = "Desc Not Required"
+    entries: List[Any]
+
+    def _add_entry(self, entry: Any, single: bool = False) -> None:
+        if self.entries and single:
+            self.entries[0] = entry
+            del self.entries[1:]
+        else:
+            self.entries.append(entry)
 
 
 class InfoTag(BaseModel):
-    info_tag: Optional[str] = Field("", alias="infoTag")
+    info_tag: Optional[str] = Field("", serialization_alias="infoTag", validation_alias="infoTag")
 
 
 class PolicyListId(BaseModel):
-    list_id: UUID = Field(alias="listId")
+    list_id: UUID = Field(serialization_alias="listId", validation_alias="listId")
+
+
+class PolicyListReference(BaseModel):
+    id: Optional[str] = Field(default=None)
+    type: Optional[str] = Field(default=None)
+
+    @property
+    def uuid(self) -> Optional[UUID]:
+        try:
+            return UUID(self.id)
+        except ValueError:
+            return None
 
 
 class PolicyListInfo(PolicyListId, InfoTag):
-    last_updated: datetime.datetime = Field(alias="lastUpdated")
+    last_updated: datetime.datetime = Field(serialization_alias="lastUpdated", validation_alias="lastUpdated")
     owner: str
-    read_only: bool = Field(alias="readOnly")
+    read_only: bool = Field(serialization_alias="readOnly", validation_alias="readOnly")
     version: str
-    reference_count: int = Field(alias="referenceCount")
-    references: List
-    is_activated_by_vsmart: Optional[bool] = Field(None, alias="isActivatedByVsmart")
+    reference_count: int = Field(serialization_alias="referenceCount", validation_alias="referenceCount")
+    references: List[PolicyListReference]
+    is_activated_by_vsmart: Optional[bool] = Field(
+        None, serialization_alias="isActivatedByVsmart", validation_alias="isActivatedByVsmart"
+    )
 
 
 class PolicyListPreview(BaseModel):
     preview: str
-
-
-class PolicyListEndpoints(Protocol):
-    def create_policy_list(self, payload: AnyPolicyList) -> PolicyListId:
-        ...
-
-    def delete_policy_list(self, id: UUID) -> None:
-        ...
-
-    def edit_policy_list(self, id: UUID, payload: AnyPolicyList) -> None:
-        ...
-
-    def get_lists_by_id(self, id: UUID) -> PolicyListInfo:
-        ...
-
-    def get_policy_lists(self) -> DataSequence[PolicyListInfo]:
-        ...

catalystwan/models/policy/security.py

@@ -1,12 +1,13 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
-from typing import List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Set, Union
 from uuid import UUID
 
-from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, RootModel, field_validator
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, IPvAnyAddress, RootModel, field_validator
 from typing_extensions import Annotated
 
 from catalystwan.models.policy.policy import (
+    AdvancedInspectionProfileAssemblyItem,
     AdvancedMalwareProtectionAssemblyItem,
     DNSSecurityAssemblyItem,
     IntrusionPreventionAssemblyItem,
@@ -18,23 +19,35 @@ from catalystwan.models.policy.policy import (
     URLFilteringAssemblyItem,
     ZoneBasedFWAssemblyItem,
 )
+from catalystwan.typed_list import DataSequence
+
+
+def set_default_policy_mode_if_missing(values: Any):
+    if not isinstance(values, dict):
+        return values
+    if "policyMode" not in values.keys():
+        values["policyMode"] = None
+    return values
+
 
 SecurityPolicyAssemblyItem = Annotated[
     Union[
-        ZoneBasedFWAssemblyItem,
-        IntrusionPreventionAssemblyItem,
-        URLFilteringAssemblyItem,
         AdvancedMalwareProtectionAssemblyItem,
         DNSSecurityAssemblyItem,
+        IntrusionPreventionAssemblyItem,
         SSLDecryptionAssemblyItem,
+        URLFilteringAssemblyItem,
+        ZoneBasedFWAssemblyItem,
     ],
     Field(discriminator="type"),
 ]
 
 UnifiedSecurityPolicyAssemblyItem = Annotated[
     Union[
-        NGFirewallAssemblyItem,
+        AdvancedInspectionProfileAssemblyItem,
         DNSSecurityAssemblyItem,
+        NGFirewallAssemblyItem,
+        SSLDecryptionAssemblyItem,
     ],
     Field(discriminator="type"),
 ]
@@ -52,9 +65,11 @@ ZoneToNoZoneInternet = Literal[
 
 class HighSpeedLoggingEntry(BaseModel):
     vrf: str
-    server_ip: IPvAnyAddress = Field(alias="serverIp")
+    server_ip: IPvAnyAddress = Field(serialization_alias="serverIp", validation_alias="serverIp")
     port: str
-    source_interface: Optional[str] = Field(alias="sourceInterface")
+    source_interface: Optional[str] = Field(
+        default=None, serialization_alias="sourceInterface", validation_alias="sourceInterface"
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
@@ -64,66 +79,105 @@ class HighSpeedLoggingList(BaseModel):
 
 class LoggingEntry(BaseModel):
     vpn: str
-    server_ip: IPvAnyAddress = Field(alias="serverIP")
+    server_ip: IPvAnyAddress = Field(serialization_alias="serverIP", validation_alias="serverIP")
     model_config = ConfigDict(populate_by_name=True)
 
 
 class SecurityPolicySettings(BaseModel):
     logging: Optional[List[LoggingEntry]] = None
-    failure_mode: Optional[FailureMode] = Field(default=None, alias="failureMode")
-    zone_to_no_zone_internet: ZoneToNoZoneInternet = Field(default="deny", alias="zoneToNozoneInternet")
-    tcp_syn_flood_limit: Optional[str] = Field(default=None, alias="tcpSynFloodLimit")
-    high_speed_logging: Optional[HighSpeedLoggingEntry] = Field(default=None, alias="highSpeedLogging")
-    audit_trail: Optional[str] = Field(default=None, alias="auditTrail")
-    platform_match: Optional[str] = Field(default=None, alias="platformMatch")
+    failure_mode: Optional[FailureMode] = Field(
+        default=None, serialization_alias="failureMode", validation_alias="failureMode"
+    )
+    zone_to_no_zone_internet: ZoneToNoZoneInternet = Field(
+        default="deny", serialization_alias="zoneToNozoneInternet", validation_alias="zoneToNozoneInternet"
+    )
+    tcp_syn_flood_limit: Optional[str] = Field(
+        default=None, serialization_alias="tcpSynFloodLimit", validation_alias="tcpSynFloodLimit"
+    )
+    high_speed_logging: Union[HighSpeedLoggingEntry, HighSpeedLoggingList, None] = Field(
+        default=None, serialization_alias="highSpeedLogging", validation_alias="highSpeedLogging"
+    )
+    audit_trail: Optional[str] = Field(default=None, serialization_alias="auditTrail", validation_alias="auditTrail")
+    platform_match: Optional[str] = Field(
+        default=None, serialization_alias="platformMatch", validation_alias="platformMatch"
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class UnifiedSecurityPolicySettings(BaseModel):
-    tcp_syn_flood_limit: Optional[str] = Field(default=None, alias="tcpSynFloodLimit")
-    max_incomplete_tcp_limit: Optional[str] = Field(default=None, alias="maxIncompleteTcpLimit")
-    max_incomplete_udp_limit: Optional[str] = Field(default=None, alias="maxIncompleteUdpLimit")
-    max_incomplete_icmp_limit: Optional[str] = Field(default=None, alias="maxIncompleteIcmpLimit")
-    high_speed_logging: Optional[HighSpeedLoggingList] = Field(default=None, alias="highSpeedLogging")
+    tcp_syn_flood_limit: Optional[str] = Field(
+        default=None, serialization_alias="tcpSynFloodLimit", validation_alias="tcpSynFloodLimit"
+    )
+    max_incomplete_tcp_limit: Optional[str] = Field(
+        default=None, serialization_alias="maxIncompleteTcpLimit", validation_alias="maxIncompleteTcpLimit"
+    )
+    max_incomplete_udp_limit: Optional[str] = Field(
+        default=None, serialization_alias="maxIncompleteUdpLimit", validation_alias="maxIncompleteUdpLimit"
+    )
+    max_incomplete_icmp_limit: Optional[str] = Field(
+        default=None, serialization_alias="maxIncompleteIcmpLimit", validation_alias="maxIncompleteIcmpLimit"
+    )
+    high_speed_logging: Union[HighSpeedLoggingEntry, HighSpeedLoggingList, None] = Field(
+        default=None, serialization_alias="highSpeedLogging", validation_alias="highSpeedLogging"
+    )
+    audit_trail: Optional[str] = Field(default=None, serialization_alias="auditTrail", validation_alias="auditTrail")
+    unified_logging: Optional[str] = Field(
+        default=None, serialization_alias="unifiedLogging", validation_alias="unifiedLogging"
+    )
+    session_reclassify_allow: Optional[str] = Field(
+        default=None, serialization_alias="sessionReclassifyAllow", validation_alias="sessionReclassifyAllow"
+    )
+    icmp_unreachable_allow: Optional[str] = Field(
+        default=None, serialization_alias="icmpUnreachableAllow", validation_alias="icmpUnreachableAllow"
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class SecurityPolicyDefinition(PolicyDefinition):
     assembly: List[SecurityPolicyAssemblyItem] = []
-    settings: SecurityPolicySettings = SecurityPolicySettings()
+    settings: SecurityPolicySettings = Field(default=SecurityPolicySettings())
 
 
 class UnifiedSecurityPolicyDefinition(PolicyDefinition):
     assembly: List[UnifiedSecurityPolicyAssemblyItem] = []
-    settings: UnifiedSecurityPolicySettings = UnifiedSecurityPolicySettings()
+    settings: UnifiedSecurityPolicySettings = Field(default=UnifiedSecurityPolicySettings())
 
 
 class SecurityPolicy(PolicyCreationPayload):
-    policy_mode: Literal["security"] = Field(default="security", alias="policyMode")
-    policy_type: str = Field(default="feature", alias="policyType")
-    policy_use_case: str = Field(default="custom", alias="policyUseCase")
-    policy_definition: SecurityPolicyDefinition = Field(default=SecurityPolicyDefinition(), alias="policyDefinition")
+    policy_mode: Literal[None, "", "security"] = Field(
+        default="security", serialization_alias="policyMode", validation_alias="policyMode"
+    )
+    policy_type: str = Field(default="feature", serialization_alias="policyType", validation_alias="policyType")
+    policy_use_case: str = Field(
+        default="custom", serialization_alias="policyUseCase", validation_alias="policyUseCase"
+    )
+    policy_definition: SecurityPolicyDefinition = Field(
+        default=SecurityPolicyDefinition(), serialization_alias="policyDefinition", validation_alias="policyDefinition"
+    )
 
-    def add_item(self, item: SecurityPolicyAssemblyItem) -> None:
+    def get_assemby_item_uuids(self) -> Set[UUID]:
+        return set((item.definition_id for item in self.policy_definition.assembly))
+
+    def _add_item(self, item: SecurityPolicyAssemblyItem) -> None:
         self.policy_definition.assembly.append(item)
 
     def add_zone_based_fw(self, definition_id: UUID) -> None:
-        self.add_item(ZoneBasedFWAssemblyItem(definition_id=definition_id))
+        self._add_item(ZoneBasedFWAssemblyItem(definition_id=definition_id))
 
     def add_dns_security(self, definition_id: UUID) -> None:
-        self.add_item(DNSSecurityAssemblyItem(definition_id=definition_id))
+        self._add_item(DNSSecurityAssemblyItem(definition_id=definition_id))
 
     def add_intrusion_prevention(self, definition_id: UUID) -> None:
-        self.add_item(IntrusionPreventionAssemblyItem(definition_id=definition_id))
+        self._add_item(IntrusionPreventionAssemblyItem(definition_id=definition_id))
 
     def add_url_filtering(self, definition_id: UUID) -> None:
-        self.add_item(URLFilteringAssemblyItem(definition_id=definition_id))
+        self._add_item(URLFilteringAssemblyItem(definition_id=definition_id))
 
     def add_advanced_malware_protection(self, definition_id: UUID) -> None:
-        self.add_item(AdvancedMalwareProtectionAssemblyItem(definition_id=definition_id))
+        self._add_item(AdvancedMalwareProtectionAssemblyItem(definition_id=definition_id))
 
     def add_ssl_decryption(self, definition_id: UUID) -> None:
-        self.add_item(SSLDecryptionAssemblyItem(definition_id=definition_id))
+        self._add_item(SSLDecryptionAssemblyItem(definition_id=definition_id))
 
     @field_validator("policy_definition", mode="before")
     @classmethod
@@ -134,16 +188,28 @@ class SecurityPolicy(PolicyCreationPayload):
 
 
 class UnifiedSecurityPolicy(PolicyCreationPayload):
-    policy_mode: Literal["unified"] = Field("unified", alias="policyMode")
-    policy_type: str = Field("feature", alias="policyType")
-    policy_use_case: str = Field("custom", alias="policyUseCase")
+    policy_mode: Literal["unified"] = Field(
+        default="unified", serialization_alias="policyMode", validation_alias="policyMode"
+    )
+    policy_type: str = Field(default="feature", serialization_alias="policyType", validation_alias="policyType")
+    policy_use_case: str = Field(
+        default="custom", serialization_alias="policyUseCase", validation_alias="policyUseCase"
+    )
     policy_definition: UnifiedSecurityPolicyDefinition = Field(
-        default=UnifiedSecurityPolicyDefinition(), alias="policyDefinition"
+        default=UnifiedSecurityPolicyDefinition(),
+        serialization_alias="policyDefinition",
+        validation_alias="policyDefinition",
     )
 
+    def get_assemby_item_uuids(self) -> Set[UUID]:
+        return set((item.definition_id for item in self.policy_definition.assembly))
+
     def add_item(self, item: UnifiedSecurityPolicyAssemblyItem) -> None:
         self.policy_definition.assembly.append(item)
 
+    def add_advanced_inspection_profile(self, definition_id: UUID) -> None:
+        self.add_item(AdvancedInspectionProfileAssemblyItem(definition_id=definition_id))
+
     def add_ng_firewall(self, definition_id: UUID) -> NGFirewallAssemblyItem:
         ng_fw = NGFirewallAssemblyItem(definition_id=definition_id)
         self.add_item(ng_fw)
@@ -152,6 +218,9 @@ class UnifiedSecurityPolicy(PolicyCreationPayload):
     def add_dns_security(self, definition_id: UUID) -> None:
         self.add_item(DNSSecurityAssemblyItem(definition_id=definition_id))
 
+    def add_ssl_decryption(self, definition_id: UUID) -> None:
+        self.add_item(SSLDecryptionAssemblyItem(definition_id=definition_id))
+
     @field_validator("policy_definition", mode="before")
     @classmethod
     def try_parse(cls, policy_definition):
@@ -160,7 +229,14 @@ class UnifiedSecurityPolicy(PolicyCreationPayload):
         return policy_definition
 
 
-AnySecurityPolicy = Annotated[Union[SecurityPolicy, UnifiedSecurityPolicy], Field(discriminator="policy_mode")]
+AnySecurityPolicy = Annotated[
+    Union[
+        SecurityPolicy,
+        UnifiedSecurityPolicy,
+    ],
+    Field(discriminator="policy_mode"),
+    BeforeValidator(set_default_policy_mode_if_missing),
+]
 
 
 class SecurityPolicyRoot(RootModel):
@@ -168,23 +244,46 @@ class SecurityPolicyRoot(RootModel):
 
 
 class SecurityPolicyEditResponse(BaseModel):
-    master_templates_affected: List[str] = Field(default=[], alias="masterTemplatesAffected")
+    master_templates_affected: List[str] = Field(
+        default_factory=list, serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
+    )
 
 
 class SecurityPolicyInfo(SecurityPolicy, PolicyInfo):
-    virtual_application_templates: List[str] = Field(alias="virtualApplicationTemplates")
-    supported_devices: List[str] = Field(alias="supportedDevices")
+    virtual_application_templates: List[str] = Field(
+        serialization_alias="virtualApplicationTemplates", validation_alias="virtualApplicationTemplates"
+    )
+    supported_devices: List[str] = Field(serialization_alias="supportedDevices", validation_alias="supportedDevices")
 
 
 class UnifiedSecurityPolicyInfo(UnifiedSecurityPolicy, PolicyInfo):
-    virtual_application_templates: List[str] = Field(alias="virtualApplicationTemplates")
-    supported_devices: List[str] = Field(alias="supportedDevices")
+    virtual_application_templates: List[str] = Field(
+        serialization_alias="virtualApplicationTemplates", validation_alias="virtualApplicationTemplates"
+    )
+    supported_devices: List[str] = Field(serialization_alias="supportedDevices", validation_alias="supportedDevices")
 
 
 AnySecurityPolicyInfo = Annotated[
-    Union[SecurityPolicyInfo, UnifiedSecurityPolicyInfo], Field(discriminator="policy_mode")
+    Union[
+        SecurityPolicyInfo,
+        UnifiedSecurityPolicyInfo,
+    ],
+    Field(discriminator="policy_mode"),
+    BeforeValidator(set_default_policy_mode_if_missing),
 ]
 
 
-class SecurityPolicyInfoRoot(RootModel):
-    root: AnySecurityPolicyInfo
+class AnySecurityPolicyInfoList(RootModel):
+    root: List[AnySecurityPolicyInfo]
+
+    @property
+    def all(self) -> List[AnySecurityPolicyInfo]:
+        return self.root
+
+    @property
+    def security(self) -> DataSequence[SecurityPolicyInfo]:
+        return DataSequence(SecurityPolicyInfo, [p for p in self.root if p.policy_mode == "security"])
+
+    @property
+    def unified(self) -> DataSequence[UnifiedSecurityPolicyInfo]:
+        return DataSequence(UnifiedSecurityPolicyInfo, [p for p in self.root if p.policy_mode == "unified"])

catalystwan/models/policy/voice.py

@@ -0,0 +1,77 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from catalystwan.models.policy.policy import AssemblyItemBase, PolicyCreationPayload, PolicyDefinition, PolicyInfo
+from catalystwan.models.policy.policy_definition import VoicePortType
+
+VoiceAssemblyItemType = Literal[
+    "dialPeer",
+    "dialpeer",
+    "fxoPort",
+    "fxoport",
+    "fxsDidPort",
+    "fxsdidport",
+    "fxsPort",
+    "fxsport",
+    "priIsdnPort",
+    "priisdnport",
+    "srstPhoneProfile",
+    "srstphoneprofile",
+]
+
+
+class VoiceAssemblyItem(AssemblyItemBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: VoiceAssemblyItemType
+    port_type: VoicePortType = Field(serialization_alias="portType", validation_alias="portType")
+
+
+class VoicePolicyDefinition(PolicyDefinition):
+    model_config = ConfigDict(populate_by_name=True)
+    assembly: List[VoiceAssemblyItem] = Field(default_factory=list)
+
+    def find_assembly_item_by_definition_id(self, definition_id: UUID) -> Optional[VoiceAssemblyItem]:
+        for item in self.assembly:
+            if item.definition_id == definition_id:
+                return item
+        return None
+
+
+class VoicePolicy(PolicyCreationPayload):
+    model_config = ConfigDict(populate_by_name=True)
+    policy_type: Literal["feature"] = Field(
+        default="feature", serialization_alias="policyType", validation_alias="policyType"
+    )
+    policy_definition: VoicePolicyDefinition = Field(
+        serialization_alias="policyDefinition",
+        validation_alias="policyDefinition",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def try_parse_policy_definition_string(cls, values):
+        # this is needed because GET /template/policy/vsmart contains string in policyDefinition field
+        # while POST /template/policy/vsmart requires a regular object
+        # it makes sense to reuse that model for both requests and present parsed data to the user
+        if not isinstance(values, dict):
+            return values
+        json_policy_type = values.get("policyType")
+        json_policy_definition = values.get("policyDefinition")
+        if json_policy_type == "feature" and isinstance(json_policy_definition, str):
+            values["policyDefinition"] = VoicePolicyDefinition.model_validate_json(json_policy_definition)
+        return values
+
+
+class VoicePolicyEditResponse(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    master_templates_affected: List[str] = Field(
+        default_factory=list, serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
+    )
+
+
+class VoicePolicyInfo(PolicyInfo, VoicePolicy):
+    pass

catalystwan/models/settings.py

@@ -0,0 +1,41 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+Region = Literal["nam", "eur"]
+
+
+class ThreatGridApiEntires(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    region: Region
+    apikey: Optional[str] = Field(default="")
+
+
+class ThreatGridApiData(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    entries: List[ThreatGridApiEntires] = Field(
+        default_factory=lambda: [
+            ThreatGridApiEntires(region="nam"),
+            ThreatGridApiEntires(region="eur"),
+        ],
+    )
+
+
+class ThreatGridApi(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    data: List[ThreatGridApiData] = Field(default_factory=lambda: [ThreatGridApiData()])
+
+    def set_region_api_key(self, region: Region, apikey: str) -> None:
+        for entry in self.data[0].entries:
+            if entry.region == region:
+                entry.apikey = apikey
+                return
+        raise ValueError(f"Region {region} not found in ThreatGridApi")
+
+    def get_region_api_key(self, region: Region) -> str:
+        for entry in self.data[0].entries:
+            if entry.region == region:
+                apikey = entry.apikey
+                return "" if apikey is None else apikey
+        raise ValueError(f"Region {region} not found in ThreatGridApi")

catalystwan/models/templates.py

@@ -0,0 +1,79 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+import datetime as dt
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+FeatureType = Literal["all", "vmanage-default", "network-design", "cloud-dock", "lawful-interception"]
+TemplateType = Literal["file", "template"]  # file == cli, template == feature
+
+
+class TemplateInformation(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    last_updated_by: str = Field(serialization_alias="lastUpdatedBy", validation_alias="lastUpdatedBy")
+    id: str = Field(serialization_alias="templateId", validation_alias="templateId")
+    factory_default: bool = Field(serialization_alias="factoryDefault", validation_alias="factoryDefault")
+    name: str = Field(serialization_alias="templateName", validation_alias="templateName")
+    devices_attached: int = Field(serialization_alias="devicesAttached", validation_alias="devicesAttached")
+    description: str = Field(serialization_alias="templateDescription", validation_alias="templateDescription")
+
+
+class FeatureTemplateInformation(TemplateInformation):
+    model_config = ConfigDict(populate_by_name=True)
+
+    template_type: str = Field(serialization_alias="templateType", validation_alias="templateType")
+    device_type: List[str] = Field(serialization_alias="deviceType", validation_alias="deviceType")
+    version: str = Field(serialization_alias="templateMinVersion", validation_alias="templateMinVersion")
+    template_definition: Optional[str] = Field(
+        default=None, serialization_alias="templateDefinition", validation_alias="templateDefinition"
+    )
+    created_by: Optional[str] = Field(default=None, serialization_alias="createdBy", validation_alias="createdBy")
+    created_on: Optional[int] = Field(default=None, serialization_alias="createdOn", validation_alias="createdOn")
+    last_updated_on: dt.datetime = Field(serialization_alias="lastUpdatedOn", validation_alias="lastUpdatedOn")
+    config_type: Optional[str] = Field(default=None, serialization_alias="configType", validation_alias="configType")
+    attached_masters_count: Optional[int] = Field(
+        default=None, serialization_alias="attachedMastersCount", validation_alias="attachedMastersCount"
+    )
+    devices_attached: int = Field(serialization_alias="devicesAttached", validation_alias="devicesAttached")
+    resource_group: Optional[str] = Field(
+        default=None, serialization_alias="resourceGroup", validation_alias="resourceGroup"
+    )
+
+
+class DeviceTemplateInformation(TemplateInformation):
+    model_config = ConfigDict(populate_by_name=True)
+
+    device_type: str = Field(serialization_alias="deviceType", validation_alias="deviceType")
+    template_class: str = Field(serialization_alias="templateClass", validation_alias="templateClass")
+    config_type: str = Field(serialization_alias="configType", validation_alias="configType")
+    template_attached: int = Field(serialization_alias="templateAttached", validation_alias="templateAttached")
+    draft_mode: Optional[str] = Field(default=None, serialization_alias="draftMode", validation_alias="draftMode")
+    device_role: Optional[str] = Field(default=None, serialization_alias="deviceRole", validation_alias="deviceRole")
+    resource_group: Optional[str] = Field(
+        default=None, serialization_alias="resourceGroup", validation_alias="resourceGroup"
+    )
+    last_updated_on: dt.datetime = Field(serialization_alias="lastUpdatedOn", validation_alias="lastUpdatedOn")
+    last_updated_by: str = Field(serialization_alias="lastUpdatedBy", validation_alias="lastUpdatedBy")
+
+
+class FeatureTemplateDefinition(TemplateInformation):
+    model_config = ConfigDict(populate_by_name=True)
+
+    template_type: str = Field(serialization_alias="templateType", validation_alias="templateType")
+    version: str = Field(serialization_alias="templateMinVersion", validation_alias="templateMinVersion")
+    device_type: List[str] = Field(serialization_alias="deviceType", validation_alias="deviceType")
+    edited_template_definition: Optional[dict] = Field(
+        serialization_alias="editedTemplateDefinition", validation_alias="editedTemplateDefinition"
+    )
+    template_definition: Optional[dict] = Field(
+        serialization_alias="templateDefinition", validation_alias="templateDefinition"
+    )
+    config_type: str = Field(serialization_alias="configType", validation_alias="configType")
+    attached_masters_count: Optional[int] = Field(
+        default=None, serialization_alias="attachedMastersCount", validation_alias="attachedMastersCount"
+    )
+    feature: FeatureType
+    created_on: Optional[int] = Field(default=None, serialization_alias="createdOn", validation_alias="createdOn")
+    created_by: Optional[str] = Field(default=None, serialization_alias="createdBy", validation_alias="createdBy")

catalystwan/response.py

@@ -9,7 +9,7 @@ from pprint import pformat
 from typing import Any, Callable, Dict, Optional, Sequence, Type, TypeVar, Union, cast
 from urllib.parse import urlparse
 
-from pydantic import BaseModel
+from pydantic import BaseModel, RootModel
 from requests import PreparedRequest, Request, Response
 from requests.cookies import RequestsCookieJar
 from requests.exceptions import JSONDecodeError
@@ -236,7 +236,11 @@ class ManagerResponse(Response, APIEndpointClientResponse):
         if issubclass(cls, BaseModel):
             if validate:
                 return cls.model_validate(data)  # type: ignore[return-value]
-            return cls.model_construct(**data)  # type: ignore[return-value]
+            else:
+                if issubclass(cls, RootModel):
+                    return cls.model_construct(data)  # type: ignore[return-value]
+                else:
+                    return cls.model_construct(**data)  # type: ignore[return-value]
         return create_dataclass(cls, data)
 
     def get_error_info(self) -> ManagerErrorInfo:

catalystwan/session.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
 
 from __future__ import annotations