catalystwan 0.41.2.dev9__py3-none-any.whl → 0.41.3__py3-none-any.whl

catalystwan/models/policy/lists_entries.py

@@ -0,0 +1,444 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+
+from ipaddress import IPv4Address, IPv4Network, IPv6Network
+from typing import List, Literal, Optional, Set
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, field_validator, model_validator
+
+from catalystwan.models.common import InterfaceType, TLOCColor, check_fields_exclusive
+
+
+def check_jitter_ms(jitter_str: str) -> str:
+    assert 1 <= int(jitter_str) <= 1000
+    return jitter_str
+
+
+def check_latency_ms(latency_str: str) -> str:
+    assert 1 <= int(latency_str) <= 1000
+    return latency_str
+
+
+def check_loss_percent(loss_str: str) -> str:
+    assert 0 <= int(loss_str) <= 100
+    return loss_str
+
+
+PolicerExceedAction = Literal[
+    "drop",
+    "remark",
+]
+
+EncapType = Literal[
+    "ipsec",
+    "gre",
+]
+
+PathPreference = Literal[
+    "direct-path",
+    "multi-hop-path",
+    "all-paths",
+]
+
+
+class ColorDSCPMap(BaseModel):
+    color: TLOCColor
+    dscp: int = Field(ge=0, le=63)
+
+
+class ColorGroupPreference(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    color_preference: str = Field(serialization_alias="colorPreference", validation_alias="colorPreference")
+    path_preference: PathPreference = Field(serialization_alias="pathPreference", validation_alias="pathPreference")
+
+    @staticmethod
+    def from_color_set_and_path(
+        color_preference: Set[TLOCColor], path_preference: PathPreference
+    ) -> "ColorGroupPreference":
+        return ColorGroupPreference(color_preference=" ".join(color_preference), path_preference=path_preference)
+
+
+class FallbackBestTunnel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    criteria: str
+    jitter_variance: Optional[str] = Field(
+        default=None,
+        serialization_alias="jitterVariance",
+        validation_alias="jitterVariance",
+        description="jitter variance in ms",
+    )
+    latency_variance: Optional[str] = Field(
+        default=None,
+        serialization_alias="latencyVariance",
+        validation_alias="latencyVariance",
+        description="latency variance in ms",
+    )
+    loss_variance: Optional[str] = Field(
+        default=None,
+        serialization_alias="lossVariance",
+        validation_alias="lossVariance",
+        description="loss variance as percentage",
+    )
+    _criteria_priority: List[Literal["jitter", "latency", "loss"]] = []
+
+    # validators
+    _jitter_validator = field_validator("jitter_variance")(check_jitter_ms)
+    _latency_validator = field_validator("latency_variance")(check_latency_ms)
+    _loss_validator = field_validator("loss_variance")(check_loss_percent)
+
+    @model_validator(mode="after")
+    def check_criteria(self):
+        expected_criteria = set()
+        if self.jitter_variance is not None:
+            expected_criteria.add("jitter")
+        if self.latency_variance is not None:
+            expected_criteria.add("latency")
+        if self.loss_variance is not None:
+            expected_criteria.add("loss")
+        assert expected_criteria, "At least one variance type needs to be present"
+        self._criteria_priority = str(self.criteria).split("-")
+        observed_criteria = set(self._criteria_priority)
+        assert expected_criteria == observed_criteria
+        return self
+
+    def _update_criteria_field(self) -> None:
+        self.criteria = f"{'-'.join(self._criteria_priority)}"
+
+    def add_jitter_criteria(self, jitter_variance: int) -> None:
+        if self.jitter_variance is None:
+            self._criteria_priority.append("jitter")
+        self.jitter_variance = str(jitter_variance)
+        self._update_criteria_field()
+        self.check_criteria
+
+    def add_latency_criteria(self, latency_variance: int) -> None:
+        if self.latency_variance is None:
+            self._criteria_priority.append("latency")
+        self.latency_variance = str(latency_variance)
+        self._update_criteria_field()
+        self.check_criteria
+
+    def add_loss_criteria(self, loss_variance: int) -> None:
+        if self.loss_variance is None:
+            self._criteria_priority.append("loss")
+        self.loss_variance = str(loss_variance)
+        self._update_criteria_field()
+        self.check_criteria
+
+
+class DataPrefixListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    ip_prefix: IPv4Network = Field(serialization_alias="ipPrefix", validation_alias="ipPrefix")
+
+
+class SiteListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    site_id: str = Field(serialization_alias="siteId", validation_alias="siteId")
+
+
+class VPNListEntry(BaseModel):
+    vpn: str = Field(description="0-65530 range or single number")
+
+    @field_validator("vpn")
+    @classmethod
+    def check_vpn_range(cls, vpns_str: str):
+        vpns = [int(vpn) for vpn in vpns_str.split("-")]
+        assert len(vpns) <= 2
+        for vpn in vpns:
+            assert 0 <= vpn <= 65530
+        if len(vpns) == 2:
+            assert vpns[0] <= vpns[1]
+        return vpns_str
+
+
+class ZoneListEntry(BaseModel):
+    vpn: Optional[str] = Field(default=None, description="0-65530 single number")
+    interface: Optional[InterfaceType] = None
+
+    @field_validator("vpn")
+    @classmethod
+    def check_vpn_range(cls, vpn_str: str):
+        assert 0 <= int(vpn_str) <= 65530
+        return vpn_str
+
+    @model_validator(mode="after")
+    def check_vpn_xor_interface(self):
+        check_fields_exclusive(self.__dict__, {"vpn", "interface"}, True)
+        return self
+
+
+class FQDNListEntry(BaseModel):
+    pattern: str
+
+
+class GeoLocationListEntry(BaseModel):
+    country: Optional[str] = Field(default=None, description="ISO-3166 alpha-3 country code eg: FRA")
+    continent: Optional[str] = Field(
+        default=None, description="One of 2-letter continent codes: AF, NA, OC, AN, AS, EU, SA"
+    )
+
+    @model_validator(mode="after")
+    def check_country_xor_continent(self):
+        check_fields_exclusive(self.__dict__, {"country", "continent"}, True)
+        return self
+
+
+class PortListEntry(BaseModel):
+    port: str
+
+    @field_validator("port")
+    @classmethod
+    def check_port_range(cls, port_str: str):
+        assert 0 <= int(port_str) <= 65535
+        return port_str
+
+
+class ProtocolNameListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    protocol_name: str = Field(serialization_alias="protocolName", validation_alias="protocolName")
+
+
+class LocalAppListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    app_family: Optional[str] = Field(default=None, serialization_alias="appFamily", validation_alias="appFamily")
+    app: Optional[str] = None
+
+    @model_validator(mode="after")
+    def check_app_xor_appfamily(self):
+        check_fields_exclusive(self.__dict__, {"app", "app_family"}, True)
+        return self
+
+
+class AppListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    app_family: Optional[str] = Field(default=None, serialization_alias="appFamily", validation_alias="appFamily")
+    app: Optional[str] = None
+
+    @model_validator(mode="after")
+    def check_app_xor_appfamily(self):
+        check_fields_exclusive(self.__dict__, {"app", "app_family"}, True)
+        return self
+
+
+class ColorListEntry(BaseModel):
+    color: TLOCColor
+
+
+class DataIPv6PrefixListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    ipv6_prefix: IPv6Network = Field(serialization_alias="ipv6Prefix", validation_alias="ipv6Prefix")
+
+
+class LocalDomainListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    name_server: str = Field(
+        pattern="^[^*+].*",
+        serialization_alias="nameServer",
+        validation_alias="nameServer",
+        max_length=240,
+        description="Must be valid std regex."
+        "String cannot start with a '*' or a '+', be empty, or be more than 240 characters",
+    )
+
+
+class IPSSignatureListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    generator_id: str = Field(serialization_alias="generatorId", validation_alias="generatorId")
+    signature_id: str = Field(serialization_alias="signatureId", validation_alias="signatureId")
+
+
+class URLListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    pattern: str
+
+
+class CommunityListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    community: str = Field(description="Example: 1000:10000 or internet or local-AS or no advertise or no-export")
+
+
+class PolicerListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    burst: str = Field(description="bytes: integer in range 15000-10000000")
+    exceed: PolicerExceedAction = "drop"
+    rate: str = Field(description="bps: integer in range 8-100000000000")
+
+    @field_validator("burst")
+    @classmethod
+    def check_burst(cls, burst_str: str):
+        assert 15000 <= int(burst_str) <= 10_000_000
+        return burst_str
+
+    @field_validator("rate")
+    @classmethod
+    def check_rate(cls, rate_str: str):
+        assert 8 <= int(rate_str) <= 100_000_000_000
+        return rate_str
+
+
+class ASPathListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    as_path: str = Field(serialization_alias="asPath", validation_alias="asPath")
+
+
+class ClassMapListEntry(BaseModel):
+    queue: str
+
+    @field_validator("queue")
+    @classmethod
+    def check_queue(cls, queue_str: str):
+        assert 0 <= int(queue_str) <= 7
+        return queue_str
+
+
+class MirrorListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    remote_dest: IPvAnyAddress = Field(serialization_alias="remoteDest", validation_alias="remoteDest")
+    source: IPvAnyAddress
+
+
+class AppProbeClassListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    forwarding_class: str = Field(serialization_alias="forwardingClass", validation_alias="forwardingClass")
+    map: List[ColorDSCPMap] = []
+
+    def add_color_mapping(self, color: TLOCColor, dscp: int) -> None:
+        self.map.append(ColorDSCPMap(color=color, dscp=dscp))
+
+
+class SLAClassListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    latency: Optional[str] = None
+    loss: Optional[str] = None
+    jitter: Optional[str] = None
+    app_probe_class: Optional[UUID] = Field(serialization_alias="appProbeClass", validation_alias="appProbeClass")
+    fallback_best_tunnel: Optional[FallbackBestTunnel] = Field(
+        default=None, serialization_alias="fallbackBestTunnel", validation_alias="fallbackBestTunnel"
+    )
+
+    # validators
+    _jitter_validator = field_validator("jitter")(check_jitter_ms)
+    _latency_validator = field_validator("latency")(check_latency_ms)
+    _loss_validator = field_validator("loss")(check_loss_percent)
+
+    @model_validator(mode="after")
+    def check_at_least_one_criteria_is_set(self):
+        assert any([self.latency, self.loss, self.jitter])
+        return self
+
+    def add_fallback_jitter_criteria(self, jitter_variance: int) -> None:
+        if self.fallback_best_tunnel:
+            self.fallback_best_tunnel.add_jitter_criteria(jitter_variance)
+        else:
+            self.fallback_best_tunnel = FallbackBestTunnel(criteria="jitter", jitter_variance=str(jitter_variance))
+
+    def add_fallback_latency_criteria(self, latency_variance: int) -> None:
+        if self.fallback_best_tunnel:
+            self.fallback_best_tunnel.add_latency_criteria(latency_variance)
+        else:
+            self.fallback_best_tunnel = FallbackBestTunnel(criteria="latency", latency_variance=str(latency_variance))
+
+    def add_fallback_loss_criteria(self, loss_variance: int) -> None:
+        if self.fallback_best_tunnel:
+            self.fallback_best_tunnel.add_loss_criteria(loss_variance)
+        else:
+            self.fallback_best_tunnel = FallbackBestTunnel(criteria="loss", loss_variance=str(loss_variance))
+
+
+class TLOCListEntry(BaseModel):
+    tloc: IPv4Address
+    color: TLOCColor
+    encap: EncapType
+    preference: Optional[str] = None
+
+    @field_validator("preference")
+    @classmethod
+    def check_preference(cls, preference_str: str):
+        if preference_str is not None:
+            assert 0 <= int(preference_str) <= 2**32 - 1
+            return preference_str
+
+
+class PreferredColorGroupListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    primary_preference: ColorGroupPreference = Field(
+        serialization_alias="primaryPreference", validation_alias="primaryPreference"
+    )
+    secondary_preference: Optional[ColorGroupPreference] = Field(
+        default=None, serialization_alias="secondaryPreference", validation_alias="secondaryPreference"
+    )
+    tertiary_preference: Optional[ColorGroupPreference] = Field(
+        default=None, serialization_alias="tertiaryPreference", validation_alias="tertiaryPreference"
+    )
+
+    @model_validator(mode="after")
+    def check_optional_preferences_order(self):
+        assert not (self.secondary_preference is None and self.tertiary_preference is not None)
+        return self
+
+
+class PrefixListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    ip_prefix: IPv4Network = Field(serialization_alias="ipPrefix", validation_alias="ipPrefix")
+    ge: Optional[str] = None
+    le: Optional[str] = None
+
+    @field_validator("ge", "le", check_fields=False)
+    @classmethod
+    def check_ge_and_le(cls, ge_le_str: Optional[str]):
+        if ge_le_str is not None:
+            assert 0 <= int(ge_le_str) <= 32
+        return ge_le_str
+
+
+class IPv6PrefixListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    ipv6_prefix: IPv6Network = Field(serialization_alias="ipv6Prefix", validation_alias="ipv6Prefix")
+    ge: Optional[str] = None
+    le: Optional[str] = None
+
+    @field_validator("ge", "le", check_fields=False)
+    @classmethod
+    def check_ge_and_le(cls, ge_le_str: Optional[str]):
+        if ge_le_str is not None:
+            assert 0 <= int(ge_le_str) <= 128
+        return ge_le_str
+
+
+class RegionListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    region_id: str = Field(
+        serialization_alias="regionId", validation_alias="regionId", description="Number in range 0-63"
+    )
+
+    @field_validator("region_id")
+    @classmethod
+    def check_region_id(cls, region_id_str: str):
+        regions = [int(region_id) for region_id in region_id_str.split("-")]
+        assert len(regions) <= 2
+        for region in regions:
+            assert 0 <= region <= 63
+        if len(regions) == 2:
+            assert regions[0] <= regions[1]
+        return region_id_str

catalystwan/models/policy/localized.py

@@ -1,16 +1,15 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
 
-from typing import Any, List, Literal, Optional, Union
+from typing import List, Literal, Optional
 from uuid import UUID
 
-from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, model_validator
+from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, field_validator
 
 from catalystwan.models.policy.policy import AssemblyItemBase, PolicyCreationPayload, PolicyDefinition, PolicyInfo
 
 LocalizedPolicySupportedItemType = Literal[
     "qosMap",
     "rewriteRule",
-    "vpnQosMap",
     "vpnQoSMap",
     "acl",
     "aclv6",
@@ -19,15 +18,9 @@ LocalizedPolicySupportedItemType = Literal[
     "deviceaccesspolicyv6",
     "deviceAccessPolicyv6",
     "vedgeRoute",
-    "vedgeroute",
 ]
 
 
-def assert_feature_defintion(definition: Any) -> "LocalizedPolicyDefinition":
-    assert isinstance(definition, LocalizedPolicyDefinition)
-    return definition
-
-
 class LocalizedPolicySettings(BaseModel):
     flow_visibility: Optional[bool] = Field(
         default=None, serialization_alias="flowVisibility", validation_alias="flowVisibility"
@@ -75,25 +68,20 @@ class LocalizedPolicyAssemblyItem(AssemblyItemBase):
 
 
 class LocalizedPolicyDefinition(PolicyDefinition):
-    assembly: List[LocalizedPolicyAssemblyItem] = []
-    settings: Optional[LocalizedPolicySettings] = None
+    assembly: List[LocalizedPolicyAssemblyItem]
+    settings: LocalizedPolicySettings
 
 
 class LocalizedPolicy(PolicyCreationPayload):
-    policy_definition: Union[LocalizedPolicyDefinition, str] = Field(
+    policy_definition: LocalizedPolicyDefinition = Field(
         default=LocalizedPolicyDefinition(assembly=[], settings=LocalizedPolicySettings()),
         serialization_alias="policyDefinition",
         validation_alias="policyDefinition",
     )
-    policy_type: Literal["feature", "cli"] = Field(
-        default="feature", serialization_alias="policyType", validation_alias="policyType"
-    )
+    policy_type: str = Field(default="feature", serialization_alias="policyType", validation_alias="policyType")
 
-    def _add_item(self, type: LocalizedPolicySupportedItemType, id: UUID) -> LocalizedPolicyAssemblyItem:
-        policy_definition = assert_feature_defintion(self.policy_definition)
-        item = LocalizedPolicyAssemblyItem(type=type, definition_id=id)
-        policy_definition.assembly.append(item)
-        return item
+    def _add_item(self, type: LocalizedPolicySupportedItemType, id: UUID) -> None:
+        self.policy_definition.assembly.append(LocalizedPolicyAssemblyItem(type=type, definition_id=id))
 
     def add_qos_map(self, definition_id: UUID) -> None:
         self._add_item("qosMap", definition_id)
@@ -102,7 +90,7 @@ class LocalizedPolicy(PolicyCreationPayload):
         self._add_item("rewriteRule", definition_id)
 
     def add_vpn_qos_map(self, definition_id: UUID) -> None:
-        self._add_item("vpnQosMap", definition_id)
+        self._add_item("vpnQoSMap", definition_id)
 
     def add_access_control_list(self, definition_id: UUID) -> None:
         self._add_item("acl", definition_id)
@@ -119,21 +107,15 @@ class LocalizedPolicy(PolicyCreationPayload):
     def add_route_policy(self, definition_id: UUID) -> None:
         self._add_item("vedgeRoute", definition_id)
 
-    def set_definition(self, assembly: List[LocalizedPolicyAssemblyItem], settings: LocalizedPolicySettings) -> None:
-        self.policy_definition = LocalizedPolicyDefinition(assembly=assembly, settings=settings)
-
-    @model_validator(mode="before")
+    @field_validator("policy_definition", mode="before")
     @classmethod
-    def try_parse_policy_definition_string(cls, values):
+    def try_parse(cls, policy_definition):
         # this is needed because GET /template/policy/vedge contains string in policyDefinition field
         # while POST /template/policy/vedge 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
-        if (policy_definition := values.get("policyDefinition")) and values.get("policyType") != "cli":
-            if isinstance(policy_definition, str):
-                values["policyDefinition"] = LocalizedPolicyDefinition.model_validate_json(policy_definition)
-        return values
+        if isinstance(policy_definition, str):
+            return LocalizedPolicyDefinition.model_validate_json(policy_definition)
+        return policy_definition
 
 
 class LocalizedPolicyInfo(PolicyInfo, LocalizedPolicy):
@@ -142,7 +124,7 @@ class LocalizedPolicyInfo(PolicyInfo, LocalizedPolicy):
 
 class LocalizedPolicyEditResponse(BaseModel):
     master_templates_affected: List[str] = Field(
-        default_factory=list, serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
+        default=[], serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
     )
 
 

catalystwan/models/policy/policy.py

@@ -1,21 +1,19 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 import datetime
-from typing import Any, List, Literal, Optional, Sequence, Union
+from typing import List, Literal, Optional, Sequence, Union
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
-ZoneListId = Union[UUID, Literal["self", "default"]]
-
 
 class PolicyId(BaseModel):
     policy_id: UUID = Field(serialization_alias="policyId", validation_alias="policyId")
 
 
 class NGFirewallZoneListEntry(BaseModel):
-    src_zone_list_id: ZoneListId = Field(serialization_alias="srcZoneListId", validation_alias="srcZoneListId")
-    dst_zone_list_id: ZoneListId = Field(serialization_alias="dstZoneListId", validation_alias="dstZoneListId")
+    src_zone_list_id: UUID = Field(serialization_alias="srcZoneListId", validation_alias="srcZoneListId")
+    dst_zone_list_id: UUID = Field(serialization_alias="dstZoneListId", validation_alias="dstZoneListId")
     model_config = ConfigDict(populate_by_name=True)
 
 
@@ -27,19 +25,18 @@ class AssemblyItemBase(BaseModel):
 
 class ZoneBasedFWAssemblyItem(AssemblyItemBase):
     type: Literal["zoneBasedFW"] = "zoneBasedFW"
-    entries: Optional[List[NGFirewallZoneListEntry]] = None
 
 
 class NGFirewallAssemblyItem(AssemblyItemBase):
     type: Literal["zoneBasedFW"] = "zoneBasedFW"
     entries: List[NGFirewallZoneListEntry] = []
 
-    def add_zone_pair(self, src_zone_id: ZoneListId, dst_zone_id: ZoneListId):
+    def add_zone_pair(self, src_zone_id: UUID, dst_zone_id: UUID):
         self.entries.append(NGFirewallZoneListEntry(src_zone_list_id=src_zone_id, dst_zone_list_id=dst_zone_id))
 
 
 class DNSSecurityAssemblyItem(AssemblyItemBase):
-    type: Literal["DNSSecurity", "dnsSecurity"] = "DNSSecurity"
+    type: Literal["DNSSecurity"] = "DNSSecurity"
 
 
 class IntrusionPreventionAssemblyItem(AssemblyItemBase):
@@ -50,10 +47,6 @@ class URLFilteringAssemblyItem(AssemblyItemBase):
     type: Literal["urlFiltering"] = "urlFiltering"
 
 
-class AdvancedInspectionProfileAssemblyItem(AssemblyItemBase):
-    type: Literal["advancedInspectionProfile"] = "advancedInspectionProfile"
-
-
 class AdvancedMalwareProtectionAssemblyItem(AssemblyItemBase):
     type: Literal["advancedMalwareProtection"] = "advancedMalwareProtection"
 
@@ -64,20 +57,23 @@ class SSLDecryptionAssemblyItem(AssemblyItemBase):
 
 class PolicyDefinition(BaseModel):
     assembly: Sequence[AssemblyItemBase] = []
-    settings: Optional[Any] = None
 
 
 class PolicyCreationPayload(BaseModel):
     policy_name: str = Field(
         serialization_alias="policyName",
         validation_alias="policyName",
-        pattern="^[a-zA-Z0-9_-]{0,127}$",
+        pattern="^[a-zA-Z0-9_-]{1,127}$",
         description="Can include only alpha-numeric characters, hyphen '-' or underscore '_'; maximum 127 characters",
     )
     policy_description: str = Field(
         default="default description", serialization_alias="policyDescription", validation_alias="policyDescription"
     )
     policy_type: str = Field(serialization_alias="policyType", validation_alias="policyType")
+    policy_definition: Union[PolicyDefinition, str] = Field(
+        serialization_alias="policyDefinition",
+        validation_alias="policyDefinition",
+    )
     is_policy_activated: bool = Field(
         default=False, serialization_alias="isPolicyActivated", validation_alias="isPolicyActivated"
     )