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

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/prefered_group_color.py

@@ -1,23 +1,30 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List, Optional
+from typing import List, Literal, Optional
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field, model_validator
+from pydantic import AliasPath, BaseModel, ConfigDict, Field, field_validator, model_validator
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
 from catalystwan.models.common import TLOCColor
-from catalystwan.models.policy.lists_entries import PathPreference
+
+PathPreference = Literal[
+    "direct-path",
+    "multi-hop-path",
+    "all-paths",
+]
 
 
 class Preference(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
-    color_preference: Global[list] = Field(serialization_alias="colorPreference", validation_alias="colorPreference")
+    color_preference: Global[List[TLOCColor]] = Field(
+        serialization_alias="colorPreference", validation_alias="colorPreference"
+    )
     path_preference: Global[PathPreference] = Field(
         serialization_alias="pathPreference", validation_alias="pathPreference"
     )
 
 
-class PreferredColorGroupEntry(BaseModel):
+class PreferredColorGroupEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     primary_preference: Preference = Field(
         serialization_alias="primaryPreference", validation_alias="primaryPreference"
@@ -35,15 +42,25 @@ class PreferredColorGroupEntry(BaseModel):
             raise ValueError("Preference Entry has to have a secondary prefrence when assigning tertiary preference.")
         return self
 
+    @field_validator("secondary_preference", "tertiary_preference", mode="before")
+    @classmethod
+    def remove_empty_preferences(cls, value):
+        """handle a situation when server returns empty json object: '{}'"""
+        if not value:
+            return None
+        return value
+
 
 class PreferredColorGroupParcel(_ParcelBase):
-    entries: List[PreferredColorGroupEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["preferred-color-group"] = Field(default="preferred-color-group", exclude=True)
+    entries: List[PreferredColorGroupEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
     def add_primary(self, color_preference: List[TLOCColor], path_preference: PathPreference):
         self.entries.append(
             PreferredColorGroupEntry(
                 primary_preference=Preference(
-                    color_preference=as_global(color_preference),
+                    color_preference=Global[List[TLOCColor]](value=color_preference),
                     path_preference=as_global(path_preference, PathPreference),
                 ),
                 secondary_preference=None,
@@ -54,11 +71,13 @@ class PreferredColorGroupParcel(_ParcelBase):
     def add_secondary(self, color_preference: List[TLOCColor], path_preference: PathPreference):
         preferred_color = self.entries[0]
         preferred_color.secondary_preference = Preference(
-            color_preference=as_global(color_preference), path_preference=as_global(path_preference, PathPreference)
+            color_preference=Global[List[TLOCColor]](value=color_preference),
+            path_preference=as_global(path_preference, PathPreference),
         )
 
     def add_tertiary(self, color_preference: List[TLOCColor], path_preference: PathPreference):
         preferred_color = self.entries[0]
         preferred_color.tertiary_preference = Preference(
-            color_preference=as_global(color_preference), path_preference=as_global(path_preference, PathPreference)
+            color_preference=Global[List[TLOCColor]](value=color_preference),
+            path_preference=as_global(path_preference, PathPreference),
         )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/prefix_list.py

@@ -1,26 +1,41 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
 from ipaddress import IPv4Address, IPv4Network
-from typing import List
+from typing import List, Literal, Optional
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import AliasPath, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry
+from catalystwan.models.common import Ipv4GePrefixRangeLen, Ipv4LePrefixRangeLen, Ipv4PrefixLen
 
 
-class PrefixListEntry(BaseModel):
+class PrefixListEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     ipv4_address: Global[IPv4Address] = Field(serialization_alias="ipv4Address", validation_alias="ipv4Address")
-    ipv4_prefix_length: Global[int] = Field(serialization_alias="ipv4PrefixLength", validation_alias="ipv4PrefixLength")
+    ipv4_prefix_length: Global[Ipv4PrefixLen] = Field(
+        serialization_alias="ipv4PrefixLength", validation_alias="ipv4PrefixLength"
+    )
+    le_range_prefix_length: Optional[Global[Ipv4LePrefixRangeLen]] = Field(
+        default=None, serialization_alias="leRangePrefixLength", validation_alias="leRangePrefixLength"
+    )
+    ge_range_prefix_length: Optional[Global[Ipv4GePrefixRangeLen]] = Field(
+        default=None, serialization_alias="geRangePrefixLength", validation_alias="geRangePrefixLength"
+    )
 
 
 class PrefixListParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["prefix"] = Field(default="prefix", exclude=True)
     entries: List[PrefixListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
-    def add_prefix(self, ipv4_network: IPv4Network):
+    def add_prefix(self, ipv4_network: IPv4Network, le: Optional[int] = None, ge: Optional[int] = None):
+        le_ = Global[Ipv4LePrefixRangeLen](value=le) if le is not None else None
+        ge_ = Global[Ipv4GePrefixRangeLen](value=ge) if ge is not None else None
         self.entries.append(
             PrefixListEntry(
-                ipv4_address=as_global(ipv4_network.network_address),
-                ipv4_prefix_length=as_global(ipv4_network.prefixlen),
+                ipv4_address=Global[IPv4Address](value=ipv4_network.network_address),
+                ipv4_prefix_length=Global[int](value=ipv4_network.prefixlen),
+                le_range_prefix_length=le_,
+                ge_range_prefix_length=ge_,
             )
         )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/service_object_group.py

@@ -0,0 +1,21 @@
+# Copyright 2025 Cisco Systems, Inc. and its affiliates
+from typing import List, Literal, Optional
+
+from pydantic import AliasPath, Field
+
+from catalystwan.api.configuration_groups.parcel import _ParcelBase, _ParcelEntry
+from catalystwan.models.configuration.feature_profile.common import RefIdItem
+
+
+class ServiceObjectGrouEntries(_ParcelEntry):
+    object_group: Optional[RefIdItem] = Field(
+        default=None, validation_alias="objectGroup", serialization_alias="objectGroup"
+    )
+
+
+class ServiceObjectGroupParcel(_ParcelBase):
+    type_: Literal["service-object-group"] = Field(default="service-object-group", exclude=True)
+    entries: List[ServiceObjectGrouEntries] = Field(
+        validation_alias=AliasPath("data", "entries"),
+        description="object-group Entries",
+    )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/sla_class.py

@@ -5,25 +5,9 @@ from uuid import UUID
 
 from pydantic import AliasPath, BaseModel, ConfigDict, Field, field_validator
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
-
-SLAClassCriteria = Literal[
-    "loss",
-    "latency",
-    "jitter",
-    "loss-latency",
-    "loss-jitter",
-    "latency-loss",
-    "latency-jitter",
-    "jitter-latency",
-    "jitter-loss",
-    "loss-latency-jitter",
-    "loss-jitter-latency",
-    "latency-loss-jitter",
-    "latency-jitter-loss",
-    "jitter-latency-loss",
-    "jitter-loss-latency",
-]
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
+from catalystwan.models.common import SLAClassCriteria
+from catalystwan.models.configuration.feature_profile.common import RefIdItem
 
 
 def check_latency_ms(cls, latency: Optional[Global]):
@@ -44,12 +28,6 @@ def check_jitter_ms(cls, jitter: Optional[Global]):
     return jitter
 
 
-class SLAAppProbeClass(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-
-    ref_id: Global[UUID] = Field(serialization_alias="refId", validation_alias="refId")
-
-
 class FallbackBestTunnel(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
@@ -95,14 +73,14 @@ class FallbackBestTunnel(BaseModel):
                 raise ValueError(f"Criteria {e} is not in configured criteria {self.criteria.value}")
 
 
-class SLAClassListEntry(BaseModel):
+class SLAClassListEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
 
     latency: Optional[Global[int]] = None
     loss: Optional[Global[int]] = None
     jitter: Optional[Global[int]] = None
-    app_probe_class: Optional[SLAAppProbeClass] = Field(
-        validation_alias="appProbeClass", serialization_alias="appProbeClass"
+    app_probe_class: Optional[RefIdItem] = Field(
+        default=None, validation_alias="appProbeClass", serialization_alias="appProbeClass"
     )
     fallback_best_tunnel: Optional[FallbackBestTunnel] = Field(
         default=None, validation_alias="fallbackBestTunnel", serialization_alias="fallbackBestTunnel"
@@ -115,18 +93,21 @@ class SLAClassListEntry(BaseModel):
 
 
 class SLAClassParcel(_ParcelBase):
-    entries: List[SLAClassListEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["sla-class"] = Field(default="sla-class", exclude=True)
+    entries: List[SLAClassListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
     def add_entry(
         self,
-        app_probe_class_id: UUID,
+        app_probe_class_id: Optional[UUID] = None,
         loss: Optional[int] = None,
         jitter: Optional[int] = None,
         latency: Optional[int] = None,
     ):
+        ref = RefIdItem(ref_id=as_global(str(app_probe_class_id))) if app_probe_class_id is not None else None
         self.entries.append(
             SLAClassListEntry(
-                app_probe_class=SLAAppProbeClass(ref_id=as_global(app_probe_class_id)),
+                app_probe_class=ref,
                 loss=as_global(loss) if loss is not None else None,
                 jitter=as_global(jitter) if jitter is not None else None,
                 latency=as_global(latency) if latency is not None else None,

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/standard_community.py

@@ -1,24 +1,30 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List
+from typing import List, Literal
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import AliasPath, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
 from catalystwan.models.common import WellKnownBGPCommunities
 
 
-class StandardCommunityEntry(BaseModel):
+class StandardCommunityEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
-    standard_community: Global[WellKnownBGPCommunities] = Field(
+    standard_community: Global[str] = Field(
         serialization_alias="standardCommunity", validation_alias="standardCommunity"
     )
 
 
 class StandardCommunityParcel(_ParcelBase):
-    entries: List[StandardCommunityEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["standard-community"] = Field(default="standard-community", exclude=True)
+    entries: List[StandardCommunityEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
+
+    def _add_community(self, standard_community: str):
+        self.entries.append(StandardCommunityEntry(standard_community=as_global(standard_community)))
+
+    def add_well_known_community(self, standard_community: WellKnownBGPCommunities):
+        self._add_community(standard_community)
 
-    def add_community(self, standard_community: WellKnownBGPCommunities):
-        self.entries.append(
-            StandardCommunityEntry(standard_community=as_global(standard_community, WellKnownBGPCommunities))
-        )
+    def add_community(self, as_number: int, community_number: int) -> None:
+        self._add_community(f"{as_number}:{community_number}")

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/tloc_list.py

@@ -1,16 +1,15 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
 from ipaddress import IPv4Address
-from typing import List, Optional
+from typing import List, Literal, Optional
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field, field_validator
+from pydantic import AliasPath, ConfigDict, Field, field_validator
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
-from catalystwan.models.common import TLOCColor
-from catalystwan.models.policy.lists_entries import EncapType
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
+from catalystwan.models.common import EncapType, TLOCColor
 
 
-class TlocEntry(BaseModel):
+class TlocEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     tloc: Global[IPv4Address]
     color: Global[TLOCColor]
@@ -28,7 +27,9 @@ class TlocEntry(BaseModel):
 
 
 class TlocParcel(_ParcelBase):
-    entries: List[TlocEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["tloc"] = Field(default="tloc", exclude=True)
+    entries: List[TlocEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
     def add_entry(
         self, tloc: IPv4Address, color: TLOCColor, encapsulation: EncapType, preference: Optional[str] = None

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/aip.py

@@ -0,0 +1,64 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import Literal, Optional
+from uuid import UUID
+
+from pydantic import AliasPath, ConfigDict, Field
+
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase
+from catalystwan.models.configuration.feature_profile.common import RefIdItem
+
+TlsDecryptionAction = Literal["decrypt", "neverDecrypt", "skipDecrypt"]
+
+
+class AdvancedInspectionProfileParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["unified/advanced-inspection-profile"] = Field(
+        default="unified/advanced-inspection-profile", exclude=True
+    )
+    parcel_description: str = Field(
+        default="",
+        serialization_alias="description",
+        validation_alias="description",
+        description="Set the parcel description",
+    )
+    tls_decryption_action: Global[TlsDecryptionAction] = Field(
+        default=Global[TlsDecryptionAction](value="skipDecrypt"),
+        validation_alias=AliasPath("data", "tlsDecryptionAction"),
+    )
+    intrusion_prevention: Optional[RefIdItem] = Field(
+        default=None, validation_alias=AliasPath("data", "intrusionPrevention")
+    )
+    url_filtering: Optional[RefIdItem] = Field(default=None, validation_alias=AliasPath("data", "urlFiltering"))
+    advanced_malware_protection: Optional[RefIdItem] = Field(
+        default=None, validation_alias=AliasPath("data", "advancedMalwareProtection")
+    )
+    ssl_decryption_profile: Optional[RefIdItem] = Field(
+        default=None, validation_alias=AliasPath("data", "sslDecryptionProfile")
+    )
+
+    @classmethod
+    def create(
+        cls,
+        parcel_name: str,
+        parcel_description: str,
+        tls_decryption_action: TlsDecryptionAction = "skipDecrypt",
+        intrusion_prevention: Optional[UUID] = None,
+        url_filtering: Optional[UUID] = None,
+        advanced_malware_protection: Optional[UUID] = None,
+        ssl_decryption_profile: Optional[UUID] = None,
+    ) -> "AdvancedInspectionProfileParcel":
+        ip = RefIdItem.from_uuid(intrusion_prevention) if intrusion_prevention else None
+        uf = RefIdItem.from_uuid(url_filtering) if url_filtering else None
+        amp = RefIdItem.from_uuid(advanced_malware_protection) if advanced_malware_protection else None
+        sdp = RefIdItem.from_uuid(ssl_decryption_profile) if ssl_decryption_profile else None
+        return cls(
+            parcel_name=parcel_name,
+            parcel_description=parcel_description,
+            tls_decryption_action=Global[TlsDecryptionAction](value=tls_decryption_action),
+            intrusion_prevention=ip,
+            url_filtering=uf,
+            advanced_malware_protection=amp,
+            ssl_decryption_profile=sdp,
+        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/amp.py

@@ -0,0 +1,79 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional
+
+from pydantic import AliasPath, ConfigDict, Field
+
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase
+from catalystwan.models.common import (
+    AmpFileAlertLevel,
+    AmpFileAnalysisFileTypes,
+    AmpFileAnalysisServer,
+    AmpFileReputationServer,
+)
+
+
+class AdvancedMalwareProtectionParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["unified/advanced-malware-protection"] = Field(
+        default="unified/advanced-malware-protection", exclude=True
+    )
+    description: str = "advancedMalwareProtection"
+    match_all_vpn: Global[Literal[True]] = Field(
+        default=Global[Literal[True]](value=True), validation_alias=AliasPath("data", "matchAllVpn")
+    )
+    file_reputation_cloud_server: Global[AmpFileReputationServer] = Field(
+        validation_alias=AliasPath("data", "fileReputationCloudServer")
+    )
+    file_reputation_est_server: Global[AmpFileReputationServer] = Field(
+        validation_alias=AliasPath("data", "fileReputationEstServer")
+    )
+    file_reputation_alert: Global[AmpFileAlertLevel] = Field(
+        default=Global[AmpFileAlertLevel](value="critical"),
+        validation_alias=AliasPath("data", "fileReputationAlert"),
+    )
+    file_analysis_enabled: Global[bool] = Field(
+        default=Global[bool](value=False), validation_alias=AliasPath("data", "fileAnalysisEnabled")
+    )
+    file_analysis_cloud_server: Optional[Global[AmpFileAnalysisServer]] = Field(
+        default=None, validation_alias=AliasPath("data", "fileAnalysisCloudServer")
+    )
+    file_analysis_file_types: Optional[Global[List[AmpFileAnalysisFileTypes]]] = Field(
+        default=None, validation_alias=AliasPath("data", "fileAnalysisFileTypes")
+    )
+    file_analysis_alert: Optional[Global[AmpFileAlertLevel]] = Field(
+        default=None, validation_alias=AliasPath("data", "fileAnalysisAlert")
+    )
+
+    @classmethod
+    def create(
+        cls,
+        parcel_name: str,
+        parcel_description: str,
+        file_reputation_cloud_server: AmpFileReputationServer,
+        file_reputation_est_server: AmpFileReputationServer,
+        file_reputation_alert: AmpFileAlertLevel,
+        file_analysis_enabled: bool = False,
+        file_analysis_alert: Optional[AmpFileAlertLevel] = None,
+        file_analysis_cloud_server: Optional[AmpFileAnalysisServer] = None,
+        file_analysis_file_types: List[AmpFileAnalysisFileTypes] = [],
+    ):
+        _file_analysis_alert = Global[AmpFileAlertLevel](value=file_analysis_alert) if file_analysis_alert else None
+        _file_analysis_cloud_server = (
+            Global[AmpFileAnalysisServer](value=file_analysis_cloud_server) if file_analysis_cloud_server else None
+        )
+        _file_analysis_file_types = (
+            Global[List[AmpFileAnalysisFileTypes]](value=file_analysis_file_types) if file_analysis_file_types else None
+        )
+
+        return cls(
+            parcel_name=parcel_name,
+            parcel_description=parcel_description,
+            file_reputation_cloud_server=Global[AmpFileReputationServer](value=file_reputation_cloud_server),
+            file_reputation_est_server=Global[AmpFileReputationServer](value=file_reputation_est_server),
+            file_analysis_alert=_file_analysis_alert,
+            file_analysis_cloud_server=_file_analysis_cloud_server,
+            file_reputation_alert=Global[AmpFileAlertLevel](value=file_reputation_alert),
+            file_analysis_enabled=Global[bool](value=file_analysis_enabled),
+            file_analysis_file_types=_file_analysis_file_types,
+        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/application_list.py

@@ -1,25 +1,27 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List, Union
+from typing import List, Literal, Union
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import AliasPath, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
 
 
-class SecurityApplicationListEntry(BaseModel):
+class SecurityApplicationListEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     app_list: Global[str] = Field(serialization_alias="app", validation_alias="app")
 
 
-class SecurityApplicationFamilyListEntry(BaseModel):
+class SecurityApplicationFamilyListEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     app_list_family: Global[str] = Field(serialization_alias="appFamily", validation_alias="appFamily")
 
 
 class SecurityApplicationListParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["security-localapp"] = Field(default="security-localapp", exclude=True)
     entries: List[Union[SecurityApplicationFamilyListEntry, SecurityApplicationListEntry]] = Field(
-        default=[], validation_alias=AliasPath("data", "entries")
+        default_factory=list, validation_alias=AliasPath("data", "entries")
     )
 
     def add_application(self, application: str):

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/data_prefix.py

@@ -1,20 +1,22 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
 from ipaddress import IPv4Network
-from typing import List
+from typing import List, Literal
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import AliasPath, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
 
 
-class SecurityDataPrefixEntry(BaseModel):
+class SecurityDataPrefixEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     ip_prefix: Global[IPv4Network] = Field(serialization_alias="ipPrefix", validation_alias="ipPrefix")
 
 
 class SecurityDataPrefixParcel(_ParcelBase):
-    entries: List[SecurityDataPrefixEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["security-data-ip-prefix"] = Field(default="security-data-ip-prefix", exclude=True)
+    entries: List[SecurityDataPrefixEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
     def add_prefix(self, ip_prefix: IPv4Network):
         self.entries.append(SecurityDataPrefixEntry(ip_prefix=as_global(ip_prefix)))

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/fqdn.py

@@ -1,13 +1,13 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List
+from typing import List, Literal
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import AliasPath, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
 
 
-class FQDNListEntry(BaseModel):
+class FQDNListEntry(_ParcelEntry):
     model_config = ConfigDict(populate_by_name=True)
     pattern: Global[str] = Field(
         description="Ex: cisco.com, .*cisco.com, .*.cisco.com. Should not start with '*' or '+'"
@@ -15,7 +15,9 @@ class FQDNListEntry(BaseModel):
 
 
 class FQDNDomainParcel(_ParcelBase):
-    entries: List[FQDNListEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["security-fqdn"] = Field(default="security-fqdn", exclude=True)
+    entries: List[FQDNListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
     def from_fqdns(self, fqdns: List[str]):
         for fqdn in fqdns:

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/geolocation_list.py

@@ -1,14 +1,14 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List, Optional
+from typing import List, Literal, Optional
 
-from pydantic import AliasPath, BaseModel, Field, model_validator
+from pydantic import AliasPath, ConfigDict, Field, model_validator
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
 from catalystwan.models.common import check_fields_exclusive
 
 
-class GeoLocationListEntry(BaseModel):
+class GeoLocationListEntry(_ParcelEntry):
     country: Optional[Global[str]] = Field(default=None, description="ISO-3166 alpha-3 country code eg: FRA")
     continent: Optional[Global[str]] = Field(
         default=None, description="One of 2-letter continent codes: AF, NA, OC, AN, AS, EU, SA"
@@ -21,7 +21,9 @@ class GeoLocationListEntry(BaseModel):
 
 
 class GeoLocationListParcel(_ParcelBase):
-    entries: List[GeoLocationListEntry] = Field(default=[], validation_alias=AliasPath("data", "entries"))
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["security-geolocation"] = Field(default="security-geolocation", exclude=True)
+    entries: List[GeoLocationListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
 
     def add_country(self, country: str):
         self.entries.append(GeoLocationListEntry(country=as_global(country)))

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/identity.py

@@ -0,0 +1,30 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from typing import List, Literal, Optional
+
+from pydantic import AliasPath, Field
+
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_optional_global
+
+
+class IdentityEntry(_ParcelEntry):
+    user: Optional[Global[str]] = Field(default=None)
+    user_group: Optional[Global[str]] = Field(
+        default=None, validation_alias="userGroup", serialization_alias="userGroup"
+    )
+
+
+class IdentityParcel(_ParcelBase):
+    type_: Literal["security-identity"] = Field(default="security-identity", exclude=True)
+    entries: List[IdentityEntry] = Field(
+        validation_alias=AliasPath("data", "entries"),
+        default_factory=list,
+        description="Array of Users and User Groups",
+    )
+
+    def add_entry(self, user: Optional[str] = None, user_group: Optional[str] = None):
+        self.entries.append(
+            IdentityEntry(
+                user=as_optional_global(user),
+                user_group=as_optional_global(user_group),
+            )
+        )