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

catalystwan/models/policy/list/sla.py

@@ -0,0 +1,77 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.common import IntStr, SLAClassCriteria
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class FallbackBestTunnel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    criteria: Optional[SLAClassCriteria] = None
+    jitter_variance: Optional[IntStr] = Field(
+        default=None,
+        serialization_alias="jitterVariance",
+        validation_alias="jitterVariance",
+        description="jitter variance in ms",
+        ge=1,
+        le=1000,
+    )
+    latency_variance: Optional[IntStr] = Field(
+        default=None,
+        serialization_alias="latencyVariance",
+        validation_alias="latencyVariance",
+        description="latency variance in ms",
+        ge=1,
+        le=1000,
+    )
+    loss_variance: Optional[IntStr] = Field(
+        default=None,
+        serialization_alias="lossVariance",
+        validation_alias="lossVariance",
+        description="loss variance as percentage",
+        ge=0,
+        le=100,
+    )
+
+
+class SLAClassListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    latency: Optional[IntStr] = Field(default=None, ge=1, le=1000)
+    loss: Optional[IntStr] = Field(default=None, ge=0, le=100)
+    jitter: Optional[IntStr] = Field(default=None, ge=1, le=1000)
+    app_probe_class: Optional[UUID] = Field(
+        default=None, serialization_alias="appProbeClass", validation_alias="appProbeClass"
+    )
+    fallback_best_tunnel: Optional[FallbackBestTunnel] = Field(
+        default=None, serialization_alias="fallbackBestTunnel", validation_alias="fallbackBestTunnel"
+    )
+
+
+class SLAClassList(PolicyListBase):
+    type: Literal["sla"] = "sla"
+    entries: List[SLAClassListEntry] = []
+
+    def assign_app_probe_class(
+        self,
+        app_probe_class_id: UUID,
+        latency: Optional[int] = None,
+        loss: Optional[int] = None,
+        jitter: Optional[int] = None,
+    ) -> SLAClassListEntry:
+        entry = SLAClassListEntry(latency=latency, loss=loss, jitter=jitter, app_probe_class=app_probe_class_id)
+        self._add_entry(entry, single=True)
+        return entry
+
+
+class SLAClassListEditPayload(SLAClassList, PolicyListId):
+    pass
+
+
+class SLAClassListInfo(SLAClassList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/supervisory_disconnect.py

@@ -0,0 +1,62 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated
+
+from catalystwan.models.common import IntStr, SpaceSeparatedCustomCadenceRanges
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class DualToneModeEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    mode: Literal["dualtone_mode"] = "dualtone_mode"
+    cadence_variable: IntStr = Field(
+        ge=0, le=200, serialization_alias="cadenceVariable", validation_alias="cadenceVariable"
+    )
+    frequency_max_delay: IntStr = Field(
+        ge=10, le=100, serialization_alias="frequencyMaxDelay", validation_alias="frequencyMaxDelay"
+    )
+    frequency_max_deviation: IntStr = Field(
+        ge=10, le=125, serialization_alias="frequencyMaxDeviation", validation_alias="frequencyMaxDeviation"
+    )
+    frequency_max_power: IntStr = Field(
+        ge=0, le=20, serialization_alias="frequencyMaxPower", validation_alias="frequencyMaxPower"
+    )
+    frequency_min_power: IntStr = Field(
+        ge=10, le=35, serialization_alias="frequencyMinPower", validation_alias="frequencyMinPower"
+    )
+    frequency_min_power_twist: IntStr = Field(
+        ge=0, le=15, serialization_alias="frequencyMinPowerTwist", validation_alias="frequencyMinPowerTwist"
+    )
+
+
+class CustomModeEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    mode: Literal["custom_mode"] = "custom_mode"
+    dualtone_type: str = Field(validation_alias="dualtoneType", serialization_alias="dualtoneType")
+    cadence: SpaceSeparatedCustomCadenceRanges
+    dualtone_frequency1: IntStr = Field(
+        ge=300, le=3600, validation_alias="dualtoneFrequency1", serialization_alias="dualtoneFrequency1"
+    )
+    dualtone_frequency2: IntStr = Field(
+        ge=300, le=3600, validation_alias="dualtoneFrequency2", serialization_alias="dualtoneFrequency2"
+    )
+
+
+SupervisoryDisconnectListEntry = Annotated[Union[DualToneModeEntry, CustomModeEntry], Field(discriminator="mode")]
+
+
+class SupervisoryDisconnectList(PolicyListBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: Literal["supervisoryDisc", "supervisorydisc"] = "supervisoryDisc"
+    entries: List[SupervisoryDisconnectListEntry] = Field(default_factory=list)
+
+
+class SupervisoryDisconnectListEditPayload(SupervisoryDisconnectList, PolicyListId):
+    pass
+
+
+class SupervisoryDisconnectListInfo(SupervisoryDisconnectList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/threat_grid_api_key.py

@@ -0,0 +1,32 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+ServerRegion = Literal["nam", "eur"]
+
+
+class ThreatGridApiKeyEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    region: ServerRegion
+    api_key: str = Field(validation_alias="apikey", serialization_alias="apikey")
+
+
+class ThreatGridApiKeyList(PolicyListBase):
+    type: Literal["threatGridApiKey"] = "threatGridApiKey"
+    entries: List[ThreatGridApiKeyEntry] = []
+
+    def add_entry(self, api_key: str, region: ServerRegion) -> None:
+        entry = ThreatGridApiKeyEntry(api_key=api_key, region=region)
+        self.entries.append(entry)
+
+
+class ThreatGridApiKeyListEditPayload(ThreatGridApiKeyList, PolicyListId):
+    pass
+
+
+class ThreatGridApiKeyListInfo(ThreatGridApiKeyList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/tloc.py

@@ -0,0 +1,32 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+from ipaddress import IPv4Address
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from catalystwan.models.common import EncapType, IntStr, TLOCColor
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class TLOCListEntry(BaseModel):
+    tloc: IPv4Address
+    color: TLOCColor
+    encap: EncapType
+    preference: Optional[IntStr] = Field(default=None, ge=0, le=2**32 - 1)
+
+
+class TLOCList(PolicyListBase):
+    type: Literal["tloc"] = "tloc"
+    entries: List[TLOCListEntry] = []
+
+    def add_tloc(self, tloc: IPv4Address, color: TLOCColor, encap: EncapType, preference: Optional[int] = None) -> None:
+        self.entries.append(TLOCListEntry(tloc=tloc, color=color, encap=encap, preference=preference))
+
+
+class TLOCListEditPayload(TLOCList, PolicyListId):
+    pass
+
+
+class TLOCListInfo(TLOCList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/translation_profile.py

@@ -0,0 +1,32 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.common import IntStr
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+CallType = Literal["called", "calling"]
+
+
+class TranslationProfileEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    translation_rule: IntStr = Field(
+        ge=1, le=1073741823, validation_alias="translationRule", serialization_alias="translationRule"
+    )
+    call_type: CallType = Field(validation_alias="callType", serialization_alias="callType")
+
+
+class TranslationProfileList(PolicyListBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: Literal["translationProfile", "translationprofile"] = "translationProfile"
+    entries: List[TranslationProfileEntry] = Field(default_factory=list)
+
+
+class TranslationProfileListEditPayload(TranslationProfileList, PolicyListId):
+    pass
+
+
+class TranslationProfileListInfo(TranslationProfileList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/translation_rules.py

@@ -0,0 +1,29 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.common import IntStr
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class TranslationRulesEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    rule_num: IntStr = Field(ge=1, validation_alias="ruleNum", serialization_alias="ruleNum")
+    match: str = Field(pattern=r"^/.*/$")
+    replace: str = Field(pattern=r"^/.*/$|^reject$")
+
+
+class TranslationRulesList(PolicyListBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: Literal["translationRules", "translationrules"] = "translationRules"
+    entries: List[TranslationRulesEntry] = Field(default_factory=list)
+
+
+class TranslationRulesListEditPayload(TranslationRulesList, PolicyListId):
+    pass
+
+
+class TranslationRulesListInfo(TranslationRulesList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/trunkgroup.py

@@ -0,0 +1,56 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.common import HuntSchemeChannel as HuntSchemeMethodPrecedence
+from catalystwan.models.common import HuntSchemeMethod
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class TrunkGroupListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    hunt_scheme_method: HuntSchemeMethod = Field(
+        validation_alias="huntSchemeMethod", serialization_alias="huntSchemeMethod"
+    )
+    hunt_scheme_precedence: Optional[HuntSchemeMethodPrecedence] = Field(
+        default=None, validation_alias="huntSchemePrecedence", serialization_alias="huntSchemePrecedence"
+    )
+    max_calls_in: Optional[int] = Field(
+        default=None, validation_alias="maxCallsIn", serialization_alias="maxCallsIn", ge=0, le=1000
+    )
+    max_calls_out: Optional[int] = Field(
+        default=None, validation_alias="maxCallsOut", serialization_alias="maxCallsOut", ge=0, le=1000
+    )
+    max_retries: int = Field(validation_alias="maxRetries", serialization_alias="maxRetries", ge=1, le=5)
+
+
+class TrunkGroupList(PolicyListBase):
+    type: Literal["trunkGroup"] = "trunkGroup"
+    entries: List[TrunkGroupListEntry] = []
+
+    def add_entry(
+        self,
+        hunt_scheme_method: HuntSchemeMethod,
+        hunt_scheme_precedence: Optional[HuntSchemeMethodPrecedence],
+        max_retries: int,
+        max_calls_in: Optional[int] = None,
+        max_calls_out: Optional[int] = None,
+    ) -> None:
+        entry = TrunkGroupListEntry(
+            hunt_scheme_method=hunt_scheme_method,
+            hunt_scheme_precedence=hunt_scheme_precedence,
+            max_retries=max_retries,
+            max_calls_in=max_calls_in,
+            max_calls_out=max_calls_out,
+        )
+        self.entries.append(entry)
+
+
+class TrunkGroupListEditPayload(TrunkGroupList, PolicyListId):
+    pass
+
+
+class TrunkGroupListInfo(TrunkGroupList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/umbrella_data.py

@@ -0,0 +1,30 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class UmbrellaDataListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    api_key: Optional[str] = Field(default=None, validation_alias="apiKey", serialization_alias="apiKey")
+    secret: Optional[str] = Field(default=None)
+    api_key_v2: Optional[str] = Field(default=None, validation_alias="apiKeyV2", serialization_alias="apiKeyV2")
+    secret_v2: Optional[str] = Field(default=None, validation_alias="secretV2", serialization_alias="secretV2")
+    token: str
+    umb_org_id: str = Field(validation_alias="umbOrgId", serialization_alias="umbOrgId")
+
+
+class UmbrellaDataList(PolicyListBase):
+    type: Literal["umbrellaData"] = "umbrellaData"
+    entries: List[UmbrellaDataListEntry] = Field(default_factory=list)
+
+
+class UmbrellaDataListEditPayload(UmbrellaDataList, PolicyListId):
+    pass
+
+
+class UmbrellaDataListInfo(UmbrellaDataList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/url.py

@@ -0,0 +1,39 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal
+
+from pydantic import BaseModel, ConfigDict
+
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class URLListEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    pattern: str
+
+
+class URLAllowList(PolicyListBase):
+    type: Literal["urlWhiteList"] = "urlWhiteList"
+    entries: List[URLListEntry] = []
+
+
+class URLAllowListEditPayload(URLAllowList, PolicyListId):
+    pass
+
+
+class URLAllowListInfo(URLAllowList, PolicyListInfo):
+    pass
+
+
+class URLBlockList(PolicyListBase):
+    type: Literal["urlBlackList"] = "urlBlackList"
+    entries: List[URLListEntry] = []
+
+
+class URLBlockListEditPayload(URLBlockList, PolicyListId):
+    pass
+
+
+class URLBlockListInfo(URLBlockList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/vpn.py

@@ -0,0 +1,40 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Set, Tuple
+
+from pydantic import BaseModel, Field, field_validator
+
+from catalystwan.models.common import IntRangeStr
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class VPNListEntry(BaseModel):
+    vpn: IntRangeStr = Field(description="0-65530 range or single number")
+
+    @field_validator("vpn")
+    @classmethod
+    def check_vpn_range(cls, vpn: IntRangeStr):
+        for i in vpn:
+            if i is not None:
+                assert 0 <= i <= 65_530
+        return vpn
+
+
+class VPNList(PolicyListBase):
+    type: Literal["vpn"] = "vpn"
+    entries: List[VPNListEntry] = []
+
+    def add_vpns(self, vpns: Set[int]):
+        for vpn in vpns:
+            self._add_entry(VPNListEntry(vpn=(vpn, None)))
+
+    def add_vpn_range(self, vpn_range: Tuple[int, int]):
+        self._add_entry(VPNListEntry(vpn=vpn_range))
+
+
+class VPNListEditPayload(VPNList, PolicyListId):
+    pass
+
+
+class VPNListInfo(VPNList, PolicyListInfo):
+    pass

catalystwan/models/policy/list/zone.py

@@ -0,0 +1,46 @@
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional, Set
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from catalystwan.models.common import IntRangeStr, check_fields_exclusive
+from catalystwan.models.policy.policy_list import PolicyListBase, PolicyListId, PolicyListInfo
+
+
+class ZoneListEntry(BaseModel):
+    vpn: Optional[IntRangeStr] = Field(default=None, description="0-65530 hypenated range or single number")
+    interface: Optional[str] = None
+
+    @field_validator("vpn")
+    @classmethod
+    def check_vpn_range(cls, vpn: Optional[IntRangeStr]):
+        if vpn is not None:
+            for i in vpn:
+                if i is not None:
+                    assert 0 <= i <= 65_530
+        return vpn
+
+    @model_validator(mode="after")
+    def check_vpn_xor_interface(self):
+        check_fields_exclusive(self.__dict__, {"vpn", "interface"}, True)
+        return self
+
+
+class ZoneList(PolicyListBase):
+    type: Literal["zone"] = "zone"
+    entries: List[ZoneListEntry] = []
+
+    def assign_vpns(self, vpns: Set[int]) -> None:
+        self.entries = [ZoneListEntry(vpn=(vpn, None)) for vpn in vpns]
+
+    def assign_interfaces(self, ifs: Set[str]) -> None:
+        self.entries = [ZoneListEntry(interface=interface) for interface in ifs]
+
+
+class ZoneListEditPayload(ZoneList, PolicyListId):
+    pass
+
+
+class ZoneListInfo(ZoneList, PolicyListInfo):
+    pass

catalystwan/models/policy/localized.py

@@ -1,15 +1,16 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List, Literal, Optional
+from typing import Any, List, Literal, Optional, Union
 from uuid import UUID
 
-from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, field_validator
+from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, model_validator
 
 from catalystwan.models.policy.policy import AssemblyItemBase, PolicyCreationPayload, PolicyDefinition, PolicyInfo
 
 LocalizedPolicySupportedItemType = Literal[
     "qosMap",
     "rewriteRule",
+    "vpnQosMap",
     "vpnQoSMap",
     "acl",
     "aclv6",
@@ -18,9 +19,15 @@ 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"
@@ -68,20 +75,25 @@ class LocalizedPolicyAssemblyItem(AssemblyItemBase):
 
 
 class LocalizedPolicyDefinition(PolicyDefinition):
-    assembly: List[LocalizedPolicyAssemblyItem]
-    settings: LocalizedPolicySettings
+    assembly: List[LocalizedPolicyAssemblyItem] = []
+    settings: Optional[LocalizedPolicySettings] = None
 
 
 class LocalizedPolicy(PolicyCreationPayload):
-    policy_definition: LocalizedPolicyDefinition = Field(
+    policy_definition: Union[LocalizedPolicyDefinition, str] = Field(
         default=LocalizedPolicyDefinition(assembly=[], settings=LocalizedPolicySettings()),
         serialization_alias="policyDefinition",
         validation_alias="policyDefinition",
     )
-    policy_type: str = Field(default="feature", serialization_alias="policyType", validation_alias="policyType")
+    policy_type: Literal["feature", "cli"] = Field(
+        default="feature", serialization_alias="policyType", validation_alias="policyType"
+    )
 
-    def _add_item(self, type: LocalizedPolicySupportedItemType, id: UUID) -> None:
-        self.policy_definition.assembly.append(LocalizedPolicyAssemblyItem(type=type, definition_id=id))
+    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_qos_map(self, definition_id: UUID) -> None:
         self._add_item("qosMap", definition_id)
@@ -90,7 +102,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)
@@ -107,15 +119,21 @@ class LocalizedPolicy(PolicyCreationPayload):
     def add_route_policy(self, definition_id: UUID) -> None:
         self._add_item("vedgeRoute", definition_id)
 
-    @field_validator("policy_definition", mode="before")
+    def set_definition(self, assembly: List[LocalizedPolicyAssemblyItem], settings: LocalizedPolicySettings) -> None:
+        self.policy_definition = LocalizedPolicyDefinition(assembly=assembly, settings=settings)
+
+    @model_validator(mode="before")
     @classmethod
-    def try_parse(cls, policy_definition):
+    def try_parse_policy_definition_string(cls, values):
         # 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 isinstance(policy_definition, str):
-            return LocalizedPolicyDefinition.model_validate_json(policy_definition)
-        return policy_definition
+        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
 
 
 class LocalizedPolicyInfo(PolicyInfo, LocalizedPolicy):
@@ -124,7 +142,7 @@ class LocalizedPolicyInfo(PolicyInfo, LocalizedPolicy):
 
 class LocalizedPolicyEditResponse(BaseModel):
     master_templates_affected: List[str] = Field(
-        default=[], serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
+        default_factory=list, serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
     )
 
 

catalystwan/models/policy/policy.py

@@ -1,19 +1,21 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 import datetime
-from typing import List, Literal, Optional, Sequence, Union
+from typing import Any, 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: UUID = Field(serialization_alias="srcZoneListId", validation_alias="srcZoneListId")
-    dst_zone_list_id: UUID = Field(serialization_alias="dstZoneListId", validation_alias="dstZoneListId")
+    src_zone_list_id: ZoneListId = Field(serialization_alias="srcZoneListId", validation_alias="srcZoneListId")
+    dst_zone_list_id: ZoneListId = Field(serialization_alias="dstZoneListId", validation_alias="dstZoneListId")
     model_config = ConfigDict(populate_by_name=True)
 
 
@@ -25,13 +27,14 @@ 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: UUID, dst_zone_id: UUID):
+    def add_zone_pair(self, src_zone_id: ZoneListId, dst_zone_id: ZoneListId):
         self.entries.append(NGFirewallZoneListEntry(src_zone_list_id=src_zone_id, dst_zone_list_id=dst_zone_id))
 
 
@@ -47,6 +50,10 @@ class URLFilteringAssemblyItem(AssemblyItemBase):
     type: Literal["urlFiltering"] = "urlFiltering"
 
 
+class AdvancedInspectionProfileAssemblyItem(AssemblyItemBase):
+    type: Literal["advancedInspectionProfile"] = "advancedInspectionProfile"
+
+
 class AdvancedMalwareProtectionAssemblyItem(AssemblyItemBase):
     type: Literal["advancedMalwareProtection"] = "advancedMalwareProtection"
 
@@ -57,23 +64,20 @@ 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_-]{1,127}$",
+        pattern="^[a-zA-Z0-9_-]{0,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"
     )