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

catalystwan/models/policy/definition/route_policy.py

@@ -0,0 +1,187 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from ipaddress import IPv4Address, IPv6Address
+from typing import List, Literal, Union
+from uuid import UUID
+
+from pydantic import ConfigDict, Field
+
+from catalystwan.models.common import AcceptRejectActionType, SequenceIpType
+from catalystwan.models.policy.policy_definition import (
+    ActionSet,
+    AddressEntry,
+    AdvancedCommunityEntry,
+    AdvancedCommunityMatchFlag,
+    AggregatorActionEntry,
+    AggregatorActionEntryValue,
+    AsPathActionEntry,
+    AsPathActionEntryValue,
+    AsPathListMatchEntry,
+    AtomicAggregateActionEntry,
+    CommunityAdditiveEntry,
+    CommunityEntry,
+    DefinitionWithSequencesCommonBase,
+    ExpandedCommunityInLineEntry,
+    ExpandedCommunityListEntry,
+    ExtendedCommunityEntry,
+    LocalPreferenceEntry,
+    Match,
+    MetricEntry,
+    MetricType,
+    MetricTypeEntry,
+    NextHopActionEntry,
+    NextHopMatchEntry,
+    OMPTagEntry,
+    OriginatorEntry,
+    OriginEntry,
+    OspfTagEntry,
+    PeerEntry,
+    PolicyAcceptRejectAction,
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+    PolicyDefinitionSequenceBase,
+    WeightEntry,
+)
+
+
+class RoutePolicyRuleSequence(PolicyDefinitionSequenceBase):
+    model_config = ConfigDict(populate_by_name=True)
+    sequence_type: Literal["vedgeRoute", "vedgeroute"] = Field(
+        default="vedgeRoute", serialization_alias="sequenceType", validation_alias="sequenceType"
+    )
+    base_action: AcceptRejectActionType = Field(
+        default="reject", serialization_alias="baseAction", validation_alias="baseAction"
+    )
+
+    match: Match = Match(entries=[])
+    actions: List[ActionSet] = []
+
+    def match_address(self, address_ref: UUID):
+        self._insert_match(AddressEntry(ref=address_ref))
+
+    def match_path_list(self, path_list_ref: UUID):
+        self._insert_match(AsPathListMatchEntry(ref=path_list_ref))
+
+    def match_bgp_local_preference(self, value: int):
+        self._insert_match(LocalPreferenceEntry(value=value))
+
+    def match_metric(self, value: int):
+        self._insert_match(MetricEntry(value=value))
+
+    def match_next_hop(self, next_hop_ref: UUID):
+        self._insert_match(NextHopMatchEntry(ref=next_hop_ref))
+
+    def match_omp_tag(self, value: int):
+        self._insert_match(OMPTagEntry(value=value))
+
+    def match_origin(self, origin: Literal["egp", "igp", "incomplete"]):
+        self._insert_match(OriginEntry(value=origin))
+
+    def match_ospf_tag(self, tag: int):
+        self._insert_match(OspfTagEntry(value=tag))
+
+    def match_peer(self, address: Union[IPv4Address, IPv6Address]):
+        self._insert_match(PeerEntry(value=address))
+
+    def match_community_list(self):
+        pass
+
+    def match_standard_community_list(self, match_flag: AdvancedCommunityMatchFlag, community_lists: List[UUID]):
+        ace = AdvancedCommunityEntry(
+            match_flag=match_flag,
+            refs=community_lists,
+        )
+        self._insert_match(ace)
+
+    def match_expanded_community_list(self, expanded_community_list_ref: UUID):
+        self._insert_match(ExpandedCommunityListEntry(ref=expanded_community_list_ref))
+
+    def match_expanded_inline_community_list(self, variable_name: str):
+        self._insert_match(ExpandedCommunityInLineEntry(vip_variable_name=variable_name))
+
+    def match_extended_community_list(self, extended_community_ref: UUID):
+        self._insert_match(ExtendedCommunityEntry(ref=extended_community_ref))
+
+    def associate_aggregator_action(self, aggregator_value: int, ip_address: Union[IPv4Address, IPv6Address]):
+        self._insert_action_in_set(
+            AggregatorActionEntry(value=AggregatorActionEntryValue(aggregator=aggregator_value, ip_address=ip_address))
+        )
+
+    def associate_as_path_action(self, prepend_action: List[int], exclude_action: List[int]):
+        self._insert_action_in_set(
+            AsPathActionEntry(value=AsPathActionEntryValue(prepend=prepend_action, exclude=exclude_action))
+        )
+
+    def associate_atomic_aggregate_action(self):
+        self._insert_action_in_set(AtomicAggregateActionEntry())
+
+    def associate_origin_action(self, origin: Literal["egp", "igp", "incomplete"]):
+        self._insert_action_in_set(OriginEntry(value=origin))
+
+    def associate_originator_action(self, originator: IPv4Address):
+        self._insert_action_in_set(OriginatorEntry(value=originator))
+
+    def associate_community_by_value_action(self, community_entry: str, community_additive: bool = False):
+        self._insert_action_in_set(CommunityEntry(value=community_entry))
+
+        if community_additive:
+            self._insert_action_in_set(CommunityAdditiveEntry())
+
+    def associate_community_by_variable_action(self, variable: str, community_additive: bool = False):
+        self._insert_action_in_set(CommunityEntry(vip_variable_name=variable))
+
+        if community_additive:
+            self._insert_action_in_set(CommunityAdditiveEntry())
+
+    def associate_local_preference_action(self, value: int):
+        self._insert_action_in_set(LocalPreferenceEntry(value=value))
+
+    def associate_metric_action(self, value: int):
+        self._insert_action_in_set(MetricEntry(value=value))
+
+    def associate_nexthop_action(self, nexthop: Union[IPv4Address, IPv6Address]):
+        self._insert_action_in_set(NextHopActionEntry(value=nexthop))
+
+    def associate_metric_type_action(self, metric_type: MetricType):
+        self._insert_action_in_set(MetricTypeEntry(value=metric_type))
+
+    def associate_omp_tag_action(self, omp_tag: int):
+        self._insert_action_in_set(OMPTagEntry(value=omp_tag))
+
+    def associate_ospf_tag_action(self, ospf_tag: int):
+        self._insert_action_in_set(OspfTagEntry(value=ospf_tag))
+
+    def associate_weight_action(self, weight: int):
+        self._insert_action_in_set(WeightEntry(value=weight))
+
+
+class RoutePolicy(PolicyDefinitionBase, DefinitionWithSequencesCommonBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: Literal["vedgeRoute"] = "vedgeRoute"
+    sequences: List[RoutePolicyRuleSequence] = []
+    default_action: PolicyAcceptRejectAction = Field(
+        default=PolicyAcceptRejectAction(type="reject"),
+        serialization_alias="defaultAction",
+        validation_alias="defaultAction",
+    )
+
+    def add_sequence(
+        self, id_: int, name: str, base_action: AcceptRejectActionType, ip_type: SequenceIpType
+    ) -> RoutePolicyRuleSequence:
+        sequence = RoutePolicyRuleSequence(
+            sequence_id=id_,
+            sequence_name=name,
+            base_action=base_action,
+            sequence_ip_type=ip_type,
+        )
+        self.sequences.append(sequence)
+        return sequence
+
+
+class RoutePolicyEditPayload(RoutePolicy, PolicyDefinitionId):
+    pass
+
+
+class RoutePolicyGetResponse(RoutePolicy, PolicyDefinitionGetResponse):
+    pass

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

@@ -5,15 +5,21 @@ 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 check_fields_exclusive
-from catalystwan.models.policy.policy_definition import PolicyDefinitionBase, Reference, VariableName
+from catalystwan.models.common import IntStr, SpaceSeparatedIPv4Networks, check_fields_exclusive
+from catalystwan.models.policy.policy_definition import (
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+    Reference,
+    ReferenceList,
+    VariableName,
+)
 
 
 class RuleBase(BaseModel):
     rule: str = ""
-    order: str = ""
+    order: IntStr = 0
     action: str = "permit"
     source_security_group: Optional[Reference] = Field(
         default=None, serialization_alias="sourceSecurityGroup", validation_alias="sourceSecurityGroup"
@@ -25,7 +31,7 @@ class RuleBase(BaseModel):
     protocol_name: Optional[str] = Field(
         default=None, serialization_alias="protocolName", validation_alias="protocolName"
     )
-    protocol_name_list: Optional[Reference] = Field(
+    protocol_name_list: Optional[ReferenceList] = Field(
         default=None, serialization_alias="protocolNameList", validation_alias="protocolNameList"
     )
     model_config = ConfigDict(populate_by_name=True)
@@ -37,51 +43,53 @@ class RuleBase(BaseModel):
 
 
 class IPv4Rule(RuleBase):
-    sequence_ip_type: Literal["ipv4"] = Field(
+    sequence_ip_type: Literal[None, "ipv4"] = Field(
         default="ipv4", serialization_alias="sequenceIpType", validation_alias="sequenceIpType"
     )
-    source_ip: Union[IPv4Network, VariableName, None] = Field(
-        default=None, serialization_alias="sourceIP", validation_alias="sourceIP"
+    source_ip: Union[VariableName, SpaceSeparatedIPv4Networks, None] = Field(
+        default=None,
+        serialization_alias="sourceIP",
+        validation_alias="sourceIP",
     )
-    source_data_prefix_list: Optional[Reference] = Field(
+    source_data_prefix_list: Optional[ReferenceList] = 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[Reference] = Field(
+    source_fqdn_list: Optional[ReferenceList] = 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[Reference] = Field(
+    source_geo_location_list: Optional[ReferenceList] = 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[Reference] = Field(
+    source_port_list: Optional[ReferenceList] = Field(
         default=None, serialization_alias="sourcePortList", validation_alias="sourcePortList"
     )
-    destination_ip: Union[IPv4Network, VariableName, None] = Field(
+    destination_ip: Union[VariableName, SpaceSeparatedIPv4Networks, None] = Field(
         default=None, serialization_alias="destinationIP", validation_alias="destinationIP"
     )
-    destination_data_prefix_list: Optional[Reference] = Field(
+    destination_data_prefix_list: Optional[ReferenceList] = 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[Reference] = Field(
+    destination_fqdn_list: Optional[ReferenceList] = 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[Reference] = Field(
+    destination_geo_location_list: Optional[ReferenceList] = 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[Reference] = Field(
+    destination_port_list: Optional[ReferenceList] = Field(
         default=None, serialization_alias="destinationPortList", validation_alias="destinationPortList"
     )
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
@@ -144,7 +152,7 @@ class IPv6Rule(RuleBase):
         return self
 
 
-Rule = Annotated[Union[IPv4Rule, IPv6Rule], Field(discriminator="sequence_ip_type")]
+Rule = Union[IPv4Rule, IPv6Rule]
 
 
 class RuleSetDefinition(BaseModel):
@@ -166,7 +174,7 @@ class RuleSet(PolicyDefinitionBase):
         if from_index < 0:
             start_index = rule_count - start_index
         for i in range(start_index, rule_count):
-            order = str(i + 1)
+            order = i + 1
             self.definition.rules[i].order = order
             self.definition.rules[i].rule = f"R{order}"
 
@@ -193,28 +201,28 @@ class RuleSet(PolicyDefinitionBase):
         self,
         action: str = "permit",
         source_security_group_id: Optional[UUID] = None,
-        source_ip: Optional[IPv4Network] = None,
+        source_ip: Optional[List[IPv4Network]] = None,
         source_ip_variable: Optional[str] = None,
-        source_data_prefix_list_id: Optional[UUID] = None,
+        source_data_prefix_list_ids: Optional[List[UUID]] = None,
         source_fqdn: Optional[str] = None,
-        source_fqdn_list_id: Optional[UUID] = None,
+        source_fqdn_list_ids: Optional[List[UUID]] = None,
         source_geo_location: Optional[str] = None,
-        source_geo_location_list_id: Optional[UUID] = None,
+        source_geo_location_list_ids: Optional[List[UUID]] = None,
         source_port: Optional[str] = None,
-        source_port_list_id: Optional[UUID] = None,
+        source_port_list_ids: Optional[List[UUID]] = None,
         destination_security_group_id: Optional[UUID] = None,
-        destination_ip: Optional[IPv4Network] = None,
+        destination_ip: Optional[List[IPv4Network]] = None,
         destination_ip_variable: Optional[str] = None,
-        destination_data_prefix_list_id: Optional[UUID] = None,
+        destination_data_prefix_list_ids: Optional[List[UUID]] = None,
         destination_fqdn: Optional[str] = None,
-        destination_fqdn_list_id: Optional[UUID] = None,
+        destination_fqdn_list_ids: Optional[List[UUID]] = None,
         destination_geo_location: Optional[str] = None,
-        destination_geo_location_list_id: Optional[UUID] = None,
+        destination_geo_location_list_ids: Optional[List[UUID]] = None,
         destination_port: Optional[str] = None,
-        destination_port_list_id: Optional[UUID] = None,
+        destination_port_list_ids: Optional[List[UUID]] = None,
         protocols: Optional[List[int]] = None,
         protocol_names: Optional[str] = None,
-        protocol_name_list_id: Optional[UUID] = None,
+        protocol_name_list_ids: Optional[List[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")
@@ -224,33 +232,43 @@ 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=Reference(ref=source_data_prefix_list_id) if source_data_prefix_list_id else None,
+            source_data_prefix_list=(
+                ReferenceList(ref=source_data_prefix_list_ids) if source_data_prefix_list_ids else None
+            ),
             source_fqdn=source_fqdn,
-            source_fqdn_list=Reference(ref=source_fqdn_list_id) if source_fqdn_list_id else None,
+            source_fqdn_list=ReferenceList(ref=source_fqdn_list_ids) if source_fqdn_list_ids else None,
             source_geo_location=source_geo_location,
-            source_geo_location_list=Reference(ref=source_geo_location_list_id)
-            if source_geo_location_list_id
-            else None,
+            source_geo_location_list=(
+                ReferenceList(ref=source_geo_location_list_ids) if source_geo_location_list_ids else None
+            ),
             source_port=source_port,
-            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,
+            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
+            ),
             destination_ip=destination_ip
             or (VariableName(vip_variable_name=destination_ip_variable) if destination_ip_variable else None),
-            destination_data_prefix_list=Reference(ref=destination_data_prefix_list_id)
-            if destination_data_prefix_list_id
-            else None,
+            destination_data_prefix_list=(
+                ReferenceList(ref=destination_data_prefix_list_ids) if destination_data_prefix_list_ids else None
+            ),
             destination_fqdn=destination_fqdn,
-            destination_fqdn_list=Reference(ref=destination_fqdn_list_id) if destination_fqdn_list_id else None,
+            destination_fqdn_list=ReferenceList(ref=destination_fqdn_list_ids) if destination_fqdn_list_ids else None,
             destination_geo_location=destination_geo_location,
-            destination_geo_location_list=Reference(ref=destination_geo_location_list_id)
-            if destination_geo_location_list_id
-            else None,
+            destination_geo_location_list=(
+                ReferenceList(ref=destination_geo_location_list_ids) if destination_geo_location_list_ids else None
+            ),
             destination_port=destination_port,
-            destination_port_list=Reference(ref=destination_port_list_id) if destination_port_list_id else None,
+            destination_port_list=ReferenceList(ref=destination_port_list_ids) if destination_port_list_ids 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=Reference(ref=protocol_name_list_id) if protocol_name_list_id else None,
+            protocol_name_list=ReferenceList(ref=protocol_name_list_ids) if protocol_name_list_ids else None,
         )
         self.add(ipv4_rule)
+
+
+class RuleSetEditPayload(RuleSet, PolicyDefinitionId):
+    pass
+
+
+class RuleSetGetResponse(RuleSet, PolicyDefinitionGetResponse):
+    pass

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

@@ -6,7 +6,13 @@ 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, Reference, VariableName
+from catalystwan.models.policy.policy_definition import (
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+    ReferenceList,
+    VariableName,
+)
 
 SequenceIPType = Literal[
     "ipv4",
@@ -15,14 +21,20 @@ SequenceIPType = Literal[
 
 
 class SecurityGroupIPv4Definition(BaseModel):
-    data_prefix: Union[IPv4Network, VariableName, None] = Field(None, alias="dataPrefix")
-    data_prefix_list: Optional[Reference] = Field(None, alias="dataPrefixList")
+    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"
+    )
     fqdn: Optional[str] = None
-    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")
+    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"
+    )
     port: Optional[str] = None
-    port_list: Optional[Reference] = Field(None, alias="portList")
+    port_list: Optional[ReferenceList] = Field(None, serialization_alias="portList", validation_alias="portList")
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     @model_validator(mode="after")
@@ -40,8 +52,12 @@ class SecurityGroupIPv4Definition(BaseModel):
 
 
 class SecurityGroupIPv6Definition(BaseModel):
-    data_ipv6_prefix: Union[IPv6Network, VariableName, None] = Field(None, alias="dataIPV6Prefix")
-    data_ipv6_prefix_list: Optional[Reference] = Field(None, alias="dataIPV6PrefixList")
+    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"
+    )
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     @model_validator(mode="after")
@@ -55,15 +71,23 @@ 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(alias="sequenceIpType")
+    sequence_ip_type: SequenceIPType = Field(
+        default="ipv4", serialization_alias="sequenceIpType", validation_alias="sequenceIpType"
+    )
     definition: Union[SecurityGroupIPv4Definition, SecurityGroupIPv6Definition]
 
     @model_validator(mode="after")
     def validate_by_sequence_ip_type(self):
-        if (
-            self.sequence_ip_type == SequenceIPType.IPV4 and isinstance(self.definition, SecurityGroupIPv6Definition)
-        ) or (
-            self.sequence_ip_type == SequenceIPType.IPV6 and isinstance(self.definition, SecurityGroupIPv4Definition)
+        if (self.sequence_ip_type == "ipv6" and not isinstance(self.definition, SecurityGroupIPv6Definition)) or (
+            self.sequence_ip_type == "ipv4" and not 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

catalystwan/models/policy/definition/srst_phone_profile.py

@@ -0,0 +1,37 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.policy.policy_definition import (
+    MediaProfileRef,
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+    VoicePortType,
+)
+
+
+class SrstPhoneProfilePolicyDefinition(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    media_profile: Optional[MediaProfileRef] = Field(
+        default=None, serialization_alias="mediaProfile", validation_alias="mediaProfile"
+    )
+
+
+class SrstPhoneProfilePolicy(PolicyDefinitionBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: Literal["srstPhoneProfile", "srstphoneprofile"] = "srstPhoneProfile"
+    port_type: Optional[VoicePortType] = Field(
+        default="srstPhone", serialization_alias="portType", validation_alias="portType"
+    )
+    definition: SrstPhoneProfilePolicyDefinition = SrstPhoneProfilePolicyDefinition()
+
+
+class SrstPhoneProfilePolicyEditPayload(SrstPhoneProfilePolicy, PolicyDefinitionId):
+    pass
+
+
+class SrstPhoneProfilePolicyGetResponse(SrstPhoneProfilePolicy, PolicyDefinitionGetResponse):
+    pass