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

catalystwan/models/policy/{definition → definitions}/device_access_ipv6.py

@@ -7,18 +7,17 @@ from uuid import UUID
 from pydantic import ConfigDict, Field
 from typing_extensions import Annotated
 
-from catalystwan.models.common import AcceptDropActionType, DeviceAccessProtocolPort
 from catalystwan.models.policy.policy_definition import (
     CountAction,
+    DefaultAction,
     DefinitionWithSequencesCommonBase,
     DestinationDataIPv6PrefixListEntry,
     DestinationIPv6Entry,
     DestinationPortEntry,
+    DeviceAccessProtocol,
     Match,
-    PolicyAcceptDropAction,
+    PolicyActionType,
     PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
     PolicyDefinitionSequenceBase,
     SourceDataIPv6PrefixListEntry,
     SourceIPv6Entry,
@@ -52,18 +51,18 @@ class DeviceAccessIPv6PolicySequence(PolicyDefinitionSequenceBase):
     sequence_type: Literal["deviceaccesspolicyv6"] = Field(
         default="deviceaccesspolicyv6", serialization_alias="sequenceType", validation_alias="sequenceType"
     )
-    base_action: AcceptDropActionType = Field(
+    base_action: PolicyActionType = Field(
         default="accept", serialization_alias="baseAction", validation_alias="baseAction"
     )
     match: DeviceAccessIPv6PolicySequenceMatch = DeviceAccessIPv6PolicySequenceMatch()
     actions: List[DeviceAccessIPv6PolicySequenceActions] = []
     model_config = ConfigDict(populate_by_name=True)
 
-    def match_device_access_protocol(self, port: DeviceAccessProtocolPort) -> None:
+    def match_device_access_protocol(self, port: DeviceAccessProtocol) -> None:
         self._insert_match(DestinationPortEntry.from_port_set_and_ranges(ports={port}))
 
     def match_source_data_prefix_list(self, data_prefix_list_id: UUID) -> None:
-        self._insert_match(SourceDataIPv6PrefixListEntry(ref=[data_prefix_list_id]))
+        self._insert_match(SourceDataIPv6PrefixListEntry(ref=data_prefix_list_id))
 
     def match_source_ip(self, networks: List[IPv6Network]) -> None:
         self._insert_match(SourceIPv6Entry.from_ipv6_networks(networks))
@@ -72,7 +71,7 @@ class DeviceAccessIPv6PolicySequence(PolicyDefinitionSequenceBase):
         self._insert_match(SourcePortEntry.from_port_set_and_ranges(ports, port_ranges))
 
     def match_destination_data_prefix_list(self, data_prefix_list_id: UUID) -> None:
-        self._insert_match(DestinationDataIPv6PrefixListEntry(ref=[data_prefix_list_id]))
+        self._insert_match(DestinationDataIPv6PrefixListEntry(ref=data_prefix_list_id))
 
     def match_destination_ip(self, networks: List[IPv6Network]) -> None:
         self._insert_match(DestinationIPv6Entry.from_ipv6_networks(networks))
@@ -83,8 +82,8 @@ class DeviceAccessIPv6PolicySequence(PolicyDefinitionSequenceBase):
 
 class DeviceAccessIPv6Policy(DeviceAccessIPv6PolicyHeader, DefinitionWithSequencesCommonBase):
     sequences: List[DeviceAccessIPv6PolicySequence] = []
-    default_action: PolicyAcceptDropAction = Field(
-        default=PolicyAcceptDropAction(type="drop"),
+    default_action: DefaultAction = Field(
+        default=DefaultAction(type="drop"),
         serialization_alias="defaultAction",
         validation_alias="defaultAction",
     )
@@ -93,8 +92,8 @@ class DeviceAccessIPv6Policy(DeviceAccessIPv6PolicyHeader, DefinitionWithSequenc
     def add_acl_sequence(
         self,
         name: str = "Device Access Control List",
-        base_action: AcceptDropActionType = "accept",
-        device_access_protocol: Optional[DeviceAccessProtocolPort] = None,
+        base_action: PolicyActionType = "accept",
+        device_access_protocol: Optional[DeviceAccessProtocol] = None,
     ) -> DeviceAccessIPv6PolicySequence:
         seq = DeviceAccessIPv6PolicySequence(
             sequence_name=name,
@@ -105,11 +104,3 @@ class DeviceAccessIPv6Policy(DeviceAccessIPv6PolicyHeader, DefinitionWithSequenc
             seq.match_device_access_protocol(port=device_access_protocol)
         self.add(seq)
         return seq
-
-
-class DeviceAccessIPv6PolicyEditPayload(DeviceAccessIPv6Policy, PolicyDefinitionId):
-    pass
-
-
-class DeviceAccessIPv6PolicyGetResponse(DeviceAccessIPv6Policy, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/{definition → definitions}/hub_and_spoke.py

@@ -5,22 +5,16 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from catalystwan.models.policy.policy_definition import (
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-)
+from catalystwan.models.policy.policy_definition import PolicyDefinitionBase
 
 
 class Hub(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
     site_list: UUID = Field(validation_alias="siteList", serialization_alias="siteList")
     preference: Optional[str] = None
-    prefix_lists: List[UUID] = Field(
-        default_factory=list, validation_alias="prefixLists", serialization_alias="prefixLists"
-    )
+    prefix_lists: List[UUID] = Field(default=[], validation_alias="prefixLists", serialization_alias="prefixLists")
     ipv6_prefix_lists: List[UUID] = Field(
-        default_factory=list, validation_alias="ipv6PrefixLists", serialization_alias="ipv6PrefixLists"
+        default=[], validation_alias="ipv6PrefixLists", serialization_alias="ipv6PrefixLists"
     )
 
 
@@ -45,7 +39,7 @@ class HubAndSpokePolicyDefinition(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
     vpn_list: UUID = Field(validation_alias="vpnList", serialization_alias="vpnList")
     sub_definitions: List[HubAndSpokePolicySubDefinition] = Field(
-        default_factory=list, validation_alias="subDefinitions", serialization_alias="subDefinitions"
+        default=[], validation_alias="subDefinitions", serialization_alias="subDefinitions"
     )
 
 
@@ -77,11 +71,3 @@ class HubAndSpokePolicy(PolicyDefinitionBase):
         )
         self.definition.sub_definitions.append(sub_definition)
         return sub_definition
-
-
-class HubAndSpokePolicyEditPayload(HubAndSpokePolicy, PolicyDefinitionId):
-    pass
-
-
-class HubAndSpokePolicyGetResponse(HubAndSpokePolicy, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/{definition → definitions}/mesh.py

@@ -5,11 +5,7 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from catalystwan.models.policy.policy_definition import (
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-)
+from catalystwan.models.policy.policy_definition import PolicyDefinitionBase
 
 
 class Region(BaseModel):
@@ -37,11 +33,3 @@ class MeshPolicy(PolicyDefinitionBase):
         region = Region(name=name, site_lists=site_lists)
         self.definition.regions.append(region)
         return region
-
-
-class MeshPolicyEditPayload(MeshPolicy, PolicyDefinitionId):
-    pass
-
-
-class MeshPolicyGetResponse(MeshPolicy, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/{definition → definitions}/qos_map.py

@@ -5,12 +5,7 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
-from catalystwan.models.common import IntStr
-from catalystwan.models.policy.policy_definition import (
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-)
+from catalystwan.models.policy.policy_definition import PolicyDefinitionBase
 
 QoSScheduling = Literal[
     "llq",
@@ -24,17 +19,11 @@ QoSDropType = Literal[
 
 
 class QoSScheduler(BaseModel):
-    queue: IntStr = Field(ge=0, le=7)
-    class_map_ref: Optional[UUID] = Field(
-        default=None, serialization_alias="classMapRef", validation_alias="classMapRef"
-    )
-    bandwidth_percent: IntStr = Field(
-        default=1, ge=1, le=100, serialization_alias="bandwidthPercent", validation_alias="bandwidthPercent"
-    )
-    buffer_percent: IntStr = Field(
-        default=1, ge=1, le=100, serialization_alias="bufferPercent", validation_alias="bufferPercent"
-    )
-    burst: Optional[IntStr] = Field(default=None, ge=5000, le=10_000_000)
+    queue: str
+    class_map_ref: Union[UUID, Literal[""]] = Field(serialization_alias="classMapRef", validation_alias="classMapRef")
+    bandwidth_percent: str = Field("1", serialization_alias="bandwidthPercent", validation_alias="bandwidthPercent")
+    buffer_percent: str = Field("1", serialization_alias="bufferPercent", validation_alias="bufferPercent")
+    burst: Optional[str] = None
     scheduling: QoSScheduling = "wrr"
     drops: QoSDropType = "tail-drop"
     temp_key_values: Optional[str] = Field(
@@ -44,23 +33,35 @@ class QoSScheduler(BaseModel):
     @staticmethod
     def get_default_control_scheduler() -> "QoSScheduler":
         return QoSScheduler(
-            queue=0,
-            bandwidth_percent=100,
-            buffer_percent=100,
-            burst=15000,
+            queue="0",
+            class_map_ref="",
+            bandwidth_percent="100",
+            buffer_percent="100",
+            burst="15000",
             scheduling="llq",
             drops="tail-drop",
         )
 
     model_config = ConfigDict(populate_by_name=True)
 
-    @field_validator("class_map_ref", mode="before")
+    @field_validator("queue")
     @classmethod
-    def check_optional_class_map_ref(cls, class_map_ref: Union[str, None]):
-        # None and "" indicates missing value, both can be found in server responses
-        if not class_map_ref:
-            return None
-        return class_map_ref
+    def check_queue(cls, queue_str: str):
+        assert 0 <= int(queue_str) <= 7
+        return queue_str
+
+    @field_validator("bandwidth_percent", "buffer_percent")
+    @classmethod
+    def check_bandwidth_and_buffer_percent(cls, percent_str: str):
+        assert 1 <= int(percent_str) <= 100
+        return percent_str
+
+    @field_validator("burst")
+    @classmethod
+    def check_burst(cls, burst_val: Union[str, None]):
+        if burst_val is not None:
+            assert 5000 <= int(burst_val) <= 10_000_000
+        return burst_val
 
 
 class QoSMapDefinition(BaseModel):
@@ -85,11 +86,11 @@ class QoSMapPolicy(PolicyDefinitionBase):
     ) -> None:
         self.definition.qos_schedulers.append(
             QoSScheduler(
-                queue=queue,
+                queue=str(queue),
                 class_map_ref=class_map_ref,
-                bandwidth_percent=bandwidth,
-                buffer_percent=buffer,
-                burst=burst,
+                bandwidth_percent=str(bandwidth),
+                buffer_percent=str(buffer),
+                burst=str(burst) if burst is not None else None,
                 scheduling=scheduling,
                 drops=drops,
             )
@@ -101,11 +102,3 @@ class QoSMapPolicy(PolicyDefinitionBase):
             # Only when creating (not when value obtained from remote is present)
             self.definition = QoSMapDefinition(qos_schedulers=[QoSScheduler.get_default_control_scheduler()])
         return self
-
-
-class QoSMapPolicyEditPayload(QoSMapPolicy, PolicyDefinitionId):
-    pass
-
-
-class QoSMapPolicyGetResponse(QoSMapPolicy, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/{definition → definitions}/rewrite.py

@@ -9,8 +9,6 @@ from catalystwan.models.policy.policy_definition import (
     DefinitionWithSequencesCommonBase,
     PLPEntryType,
     PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
 )
 
 
@@ -22,7 +20,7 @@ class RewritePolicyRule(BaseModel):
     class_: UUID = Field(serialization_alias="class", validation_alias="class")
     plp: str
     dscp: str
-    l2cos: int = Field(serialization_alias="layer2Cos", validation_alias="layer2Cos")
+    l2cos: str = Field(serialization_alias="layer2Cos", validation_alias="layer2Cos")
     model_config = ConfigDict(populate_by_name=True)
 
 
@@ -34,14 +32,6 @@ class RewritePolicy(RewritePolicyHeader, DefinitionWithSequencesCommonBase):
     definition: RewritePolicyDefinition = RewritePolicyDefinition()
 
     def add_rule(self, class_map_ref: UUID, dscp: int, l2cos: int, plp: PLPEntryType) -> None:
-        self.definition.rules.append(RewritePolicyRule(class_=class_map_ref, plp=plp, dscp=str(dscp), l2cos=l2cos))
+        self.definition.rules.append(RewritePolicyRule(class_=class_map_ref, plp=plp, dscp=str(dscp), l2cos=str(l2cos)))
 
     model_config = ConfigDict(populate_by_name=True)
-
-
-class RewritePolicyEditPayload(RewritePolicy, PolicyDefinitionId):
-    pass
-
-
-class RewritePolicyGetResponse(RewritePolicy, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/{definition → definitions}/rule_set.py

@@ -5,21 +5,15 @@ from typing import List, Literal, Optional, Union
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import Annotated
 
-from catalystwan.models.common import IntStr, SpaceSeparatedIPv4Networks, check_fields_exclusive
-from catalystwan.models.policy.policy_definition import (
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-    Reference,
-    ReferenceList,
-    VariableName,
-)
+from catalystwan.models.common import check_fields_exclusive
+from catalystwan.models.policy.policy_definition import PolicyDefinitionBase, Reference, VariableName
 
 
 class RuleBase(BaseModel):
     rule: str = ""
-    order: IntStr = 0
+    order: str = ""
     action: str = "permit"
     source_security_group: Optional[Reference] = Field(
         default=None, serialization_alias="sourceSecurityGroup", validation_alias="sourceSecurityGroup"
@@ -31,7 +25,7 @@ class RuleBase(BaseModel):
     protocol_name: Optional[str] = Field(
         default=None, serialization_alias="protocolName", validation_alias="protocolName"
     )
-    protocol_name_list: Optional[ReferenceList] = Field(
+    protocol_name_list: Optional[Reference] = Field(
         default=None, serialization_alias="protocolNameList", validation_alias="protocolNameList"
     )
     model_config = ConfigDict(populate_by_name=True)
@@ -43,53 +37,51 @@ class RuleBase(BaseModel):
 
 
 class IPv4Rule(RuleBase):
-    sequence_ip_type: Literal[None, "ipv4"] = Field(
+    sequence_ip_type: Literal["ipv4"] = Field(
         default="ipv4", serialization_alias="sequenceIpType", validation_alias="sequenceIpType"
     )
-    source_ip: Union[VariableName, SpaceSeparatedIPv4Networks, None] = Field(
-        default=None,
-        serialization_alias="sourceIP",
-        validation_alias="sourceIP",
+    source_ip: Union[IPv4Network, VariableName, None] = Field(
+        default=None, serialization_alias="sourceIP", validation_alias="sourceIP"
     )
-    source_data_prefix_list: Optional[ReferenceList] = Field(
+    source_data_prefix_list: Optional[Reference] = Field(
         default=None, serialization_alias="sourceDataPrefixList", validation_alias="sourceDataPrefixList"
     )
     source_fqdn: Optional[str] = Field(default=None, serialization_alias="sourceFqdn", validation_alias="sourceFqdn")
-    source_fqdn_list: Optional[ReferenceList] = Field(
+    source_fqdn_list: Optional[Reference] = Field(
         default=None, serialization_alias="sourceFqdnList", validation_alias="sourceFqdnList"
     )
     source_geo_location: Optional[str] = Field(
         default=None, serialization_alias="sourceGeoLocation", validation_alias="sourceGeoLocation"
     )
-    source_geo_location_list: Optional[ReferenceList] = Field(
+    source_geo_location_list: Optional[Reference] = Field(
         default=None, serialization_alias="sourceGeoLocationList", validation_alias="sourceGeoLocationList"
     )
     source_port: Optional[str] = Field(default=None, serialization_alias="sourcePort", validation_alias="sourcePort")
-    source_port_list: Optional[ReferenceList] = Field(
+    source_port_list: Optional[Reference] = Field(
         default=None, serialization_alias="sourcePortList", validation_alias="sourcePortList"
     )
-    destination_ip: Union[VariableName, SpaceSeparatedIPv4Networks, None] = Field(
+    destination_ip: Union[IPv4Network, VariableName, None] = Field(
         default=None, serialization_alias="destinationIP", validation_alias="destinationIP"
     )
-    destination_data_prefix_list: Optional[ReferenceList] = Field(
+    destination_data_prefix_list: Optional[Reference] = Field(
         default=None, serialization_alias="destinationDataPrefixList", validation_alias="destinationDataPrefixList"
     )
     destination_fqdn: Optional[str] = Field(
         default=None, serialization_alias="destinationFqdn", validation_alias="destinationFqdn"
     )
-    destination_fqdn_list: Optional[ReferenceList] = Field(
+    destination_fqdn_list: Optional[Reference] = Field(
         default=None, serialization_alias="destinationFqdnList", validation_alias="destinationFqdnList"
     )
     destination_geo_location: Optional[str] = Field(
         default=None, serialization_alias="destinationGeoLocation", validation_alias="destinationGeoLocation"
     )
-    destination_geo_location_list: Optional[ReferenceList] = Field(
+    destination_geo_location_list: Optional[Reference] = Field(
         default=None, serialization_alias="destinationGeoLocationList", validation_alias="destinationGeoLocationList"
     )
     destination_port: Optional[str] = Field(
         default=None, serialization_alias="destinationPort", validation_alias="destinationPort"
     )
-    destination_port_list: Optional[ReferenceList] = Field(
+    destination_port_list: Optional[Reference] = Field(
         default=None, serialization_alias="destinationPortList", validation_alias="destinationPortList"
     )
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
@@ -152,7 +144,7 @@ class IPv6Rule(RuleBase):
         return self
 
 
-Rule = Union[IPv4Rule, IPv6Rule]
+Rule = Annotated[Union[IPv4Rule, IPv6Rule], Field(discriminator="sequence_ip_type")]
 
 
 class RuleSetDefinition(BaseModel):
@@ -174,7 +166,7 @@ class RuleSet(PolicyDefinitionBase):
         if from_index < 0:
             start_index = rule_count - start_index
         for i in range(start_index, rule_count):
-            order = i + 1
+            order = str(i + 1)
             self.definition.rules[i].order = order
             self.definition.rules[i].rule = f"R{order}"
 
@@ -201,28 +193,28 @@ class RuleSet(PolicyDefinitionBase):
         self,
         action: str = "permit",
         source_security_group_id: Optional[UUID] = None,
-        source_ip: Optional[List[IPv4Network]] = None,
+        source_ip: Optional[IPv4Network] = None,
         source_ip_variable: Optional[str] = None,
-        source_data_prefix_list_ids: Optional[List[UUID]] = None,
+        source_data_prefix_list_id: Optional[UUID] = None,
         source_fqdn: Optional[str] = None,
-        source_fqdn_list_ids: Optional[List[UUID]] = None,
+        source_fqdn_list_id: Optional[UUID] = None,
         source_geo_location: Optional[str] = None,
-        source_geo_location_list_ids: Optional[List[UUID]] = None,
+        source_geo_location_list_id: Optional[UUID] = None,
         source_port: Optional[str] = None,
-        source_port_list_ids: Optional[List[UUID]] = None,
+        source_port_list_id: Optional[UUID] = None,
         destination_security_group_id: Optional[UUID] = None,
-        destination_ip: Optional[List[IPv4Network]] = None,
+        destination_ip: Optional[IPv4Network] = None,
         destination_ip_variable: Optional[str] = None,
-        destination_data_prefix_list_ids: Optional[List[UUID]] = None,
+        destination_data_prefix_list_id: Optional[UUID] = None,
         destination_fqdn: Optional[str] = None,
-        destination_fqdn_list_ids: Optional[List[UUID]] = None,
+        destination_fqdn_list_id: Optional[UUID] = None,
         destination_geo_location: Optional[str] = None,
-        destination_geo_location_list_ids: Optional[List[UUID]] = None,
+        destination_geo_location_list_id: Optional[UUID] = None,
         destination_port: Optional[str] = None,
-        destination_port_list_ids: Optional[List[UUID]] = None,
+        destination_port_list_id: Optional[UUID] = None,
         protocols: Optional[List[int]] = None,
         protocol_names: Optional[str] = None,
-        protocol_name_list_ids: Optional[List[UUID]] = None,
+        protocol_name_list_id: Optional[UUID] = None,
     ) -> None:
         if source_ip is not None and source_ip_variable is not None:
             raise ValueError("Source IP and variable name cannot be set at the same time")
@@ -232,43 +224,33 @@ class RuleSet(PolicyDefinitionBase):
             action=action,
             source_security_group=Reference(ref=source_security_group_id) if source_security_group_id else None,
             source_ip=source_ip or (VariableName(vip_variable_name=source_ip_variable) if source_ip_variable else None),
-            source_data_prefix_list=(
-                ReferenceList(ref=source_data_prefix_list_ids) if source_data_prefix_list_ids else None
-            ),
+            source_data_prefix_list=Reference(ref=source_data_prefix_list_id) if source_data_prefix_list_id else None,
             source_fqdn=source_fqdn,
-            source_fqdn_list=ReferenceList(ref=source_fqdn_list_ids) if source_fqdn_list_ids else None,
+            source_fqdn_list=Reference(ref=source_fqdn_list_id) if source_fqdn_list_id else None,
             source_geo_location=source_geo_location,
-            source_geo_location_list=(
-                ReferenceList(ref=source_geo_location_list_ids) if source_geo_location_list_ids else None
-            ),
+            source_geo_location_list=Reference(ref=source_geo_location_list_id)
+            if source_geo_location_list_id
+            else None,
             source_port=source_port,
-            source_port_list=ReferenceList(ref=source_port_list_ids) if source_port_list_ids else None,
-            destination_security_group=(
-                Reference(ref=destination_security_group_id) if destination_security_group_id else None
-            ),
+            source_port_list=Reference(ref=source_port_list_id) if source_port_list_id else None,
+            destination_security_group=Reference(ref=destination_security_group_id)
+            if destination_security_group_id
+            else None,
             destination_ip=destination_ip
             or (VariableName(vip_variable_name=destination_ip_variable) if destination_ip_variable else None),
-            destination_data_prefix_list=(
-                ReferenceList(ref=destination_data_prefix_list_ids) if destination_data_prefix_list_ids else None
-            ),
+            destination_data_prefix_list=Reference(ref=destination_data_prefix_list_id)
+            if destination_data_prefix_list_id
+            else None,
             destination_fqdn=destination_fqdn,
-            destination_fqdn_list=ReferenceList(ref=destination_fqdn_list_ids) if destination_fqdn_list_ids else None,
+            destination_fqdn_list=Reference(ref=destination_fqdn_list_id) if destination_fqdn_list_id else None,
             destination_geo_location=destination_geo_location,
-            destination_geo_location_list=(
-                ReferenceList(ref=destination_geo_location_list_ids) if destination_geo_location_list_ids else None
-            ),
+            destination_geo_location_list=Reference(ref=destination_geo_location_list_id)
+            if destination_geo_location_list_id
+            else None,
             destination_port=destination_port,
-            destination_port_list=ReferenceList(ref=destination_port_list_ids) if destination_port_list_ids else None,
+            destination_port_list=Reference(ref=destination_port_list_id) if destination_port_list_id else None,
             protocol=" ".join(str(p) for p in protocols) if protocols else None,
             protocol_name=" ".join(p for p in protocol_names) if protocol_names else None,
-            protocol_name_list=ReferenceList(ref=protocol_name_list_ids) if protocol_name_list_ids else None,
+            protocol_name_list=Reference(ref=protocol_name_list_id) if protocol_name_list_id else None,
         )
         self.add(ipv4_rule)
-
-
-class RuleSetEditPayload(RuleSet, PolicyDefinitionId):
-    pass
-
-
-class RuleSetGetResponse(RuleSet, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/{definition → definitions}/security_group.py

@@ -6,13 +6,7 @@ from typing import Literal, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from catalystwan.models.common import check_any_of_exclusive_field_sets, check_fields_exclusive
-from catalystwan.models.policy.policy_definition import (
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-    ReferenceList,
-    VariableName,
-)
+from catalystwan.models.policy.policy_definition import PolicyDefinitionBase, Reference, VariableName
 
 SequenceIPType = Literal[
     "ipv4",
@@ -21,20 +15,14 @@ SequenceIPType = Literal[
 
 
 class SecurityGroupIPv4Definition(BaseModel):
-    data_prefix: Union[IPv4Network, VariableName, None] = Field(
-        None, serialization_alias="dataPrefix", validation_alias="dataPrefix"
-    )
-    data_prefix_list: Optional[ReferenceList] = Field(
-        None, serialization_alias="dataPrefixList", validation_alias="dataPrefixList"
-    )
+    data_prefix: Union[IPv4Network, VariableName, None] = Field(None, alias="dataPrefix")
+    data_prefix_list: Optional[Reference] = Field(None, alias="dataPrefixList")
     fqdn: Optional[str] = None
-    fqdn_list: Optional[ReferenceList] = Field(None, serialization_alias="fqdnList", validation_alias="fqdnList")
-    geo_location: Optional[str] = Field(None, serialization_alias="geoLocation", validation_alias="geoLocation")
-    geo_location_list: Optional[ReferenceList] = Field(
-        None, serialization_alias="geoLocationList", validation_alias="geoLocationList"
-    )
+    fqdn_list: Optional[Reference] = Field(None, alias="fqdnList")
+    geo_location: Optional[str] = Field(None, alias="geoLocation")
+    geo_location_list: Optional[Reference] = Field(None, alias="geoLocationList")
     port: Optional[str] = None
-    port_list: Optional[ReferenceList] = Field(None, serialization_alias="portList", validation_alias="portList")
+    port_list: Optional[Reference] = Field(None, alias="portList")
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     @model_validator(mode="after")
@@ -52,12 +40,8 @@ class SecurityGroupIPv4Definition(BaseModel):
 
 
 class SecurityGroupIPv6Definition(BaseModel):
-    data_ipv6_prefix: Union[IPv6Network, VariableName, None] = Field(
-        None, serialization_alias="dataIPV6Prefix", validation_alias="dataIPV6Prefix"
-    )
-    data_ipv6_prefix_list: Optional[ReferenceList] = Field(
-        None, serialization_alias="dataIPV6PrefixList", validation_alias="dataIPV6PrefixList"
-    )
+    data_ipv6_prefix: Union[IPv6Network, VariableName, None] = Field(None, alias="dataIPV6Prefix")
+    data_ipv6_prefix_list: Optional[Reference] = Field(None, alias="dataIPV6PrefixList")
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     @model_validator(mode="after")
@@ -71,23 +55,15 @@ class SecurityGroup(PolicyDefinitionBase):
     # EndpointAPI would need to support annotated union as payload parameter
     type: Literal["securityGroup"] = "securityGroup"
     mode: Literal["unified"] = "unified"
-    sequence_ip_type: SequenceIPType = Field(
-        default="ipv4", serialization_alias="sequenceIpType", validation_alias="sequenceIpType"
-    )
+    sequence_ip_type: SequenceIPType = Field(alias="sequenceIpType")
     definition: Union[SecurityGroupIPv4Definition, SecurityGroupIPv6Definition]
 
     @model_validator(mode="after")
     def validate_by_sequence_ip_type(self):
-        if (self.sequence_ip_type == "ipv6" and not isinstance(self.definition, SecurityGroupIPv6Definition)) or (
-            self.sequence_ip_type == "ipv4" and not isinstance(self.definition, SecurityGroupIPv4Definition)
+        if (
+            self.sequence_ip_type == SequenceIPType.IPV4 and isinstance(self.definition, SecurityGroupIPv6Definition)
+        ) or (
+            self.sequence_ip_type == SequenceIPType.IPV6 and isinstance(self.definition, SecurityGroupIPv4Definition)
         ):
             raise ValueError(f"Incompatible definition for {self.sequence_ip_type} sequence")
         return self
-
-
-class SecurityGroupEditPayload(SecurityGroup, PolicyDefinitionId):
-    pass
-
-
-class SecurityGroupGetResponse(SecurityGroup, PolicyDefinitionGetResponse):
-    pass