catalystwan 0.40.2.dev1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

catalystwan/models/policy/definition/rewrite.py

@@ -1,47 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from catalystwan.models.policy.policy_definition import (
-    DefinitionWithSequencesCommonBase,
-    PLPEntryType,
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-)
-
-
-class RewritePolicyHeader(PolicyDefinitionBase):
-    type: Literal["rewriteRule"] = "rewriteRule"
-
-
-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")
-    model_config = ConfigDict(populate_by_name=True)
-
-
-class RewritePolicyDefinition(BaseModel):
-    rules: List[RewritePolicyRule] = []
-
-
-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))
-
-    model_config = ConfigDict(populate_by_name=True)
-
-
-class RewritePolicyEditPayload(RewritePolicy, PolicyDefinitionId):
-    pass
-
-
-class RewritePolicyGetResponse(RewritePolicy, PolicyDefinitionGetResponse):
-    pass

catalystwan/models/policy/definition/route_policy.py

@@ -1,187 +0,0 @@
-# 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/definition/rule_set.py

@@ -1,270 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from ipaddress import IPv4Network, IPv6Network
-from typing import List, Literal, Optional, Union
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-from catalystwan.models.common import check_fields_exclusive
-from catalystwan.models.policy.policy_definition import (
-    PolicyDefinitionBase,
-    PolicyDefinitionGetResponse,
-    PolicyDefinitionId,
-    Reference,
-    ReferenceList,
-    VariableName,
-)
-
-
-class RuleBase(BaseModel):
-    rule: str = ""
-    order: str = ""
-    action: str = "permit"
-    source_security_group: Optional[Reference] = Field(
-        default=None, serialization_alias="sourceSecurityGroup", validation_alias="sourceSecurityGroup"
-    )
-    destination_security_group: Optional[Reference] = Field(
-        default=None, serialization_alias="destinationSecurityGroup", validation_alias="destinationSecurityGroup"
-    )
-    protocol: Optional[str] = None
-    protocol_name: Optional[str] = Field(
-        default=None, serialization_alias="protocolName", validation_alias="protocolName"
-    )
-    protocol_name_list: Optional[Reference] = Field(
-        default=None, serialization_alias="protocolNameList", validation_alias="protocolNameList"
-    )
-    model_config = ConfigDict(populate_by_name=True)
-
-    @model_validator(mode="after")
-    def check_exclusive_fields(self):
-        check_fields_exclusive(self.__dict__, {"protocol", "protocol_name", "protocol_name_list"}, False)
-        return self
-
-
-class IPv4Rule(RuleBase):
-    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_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[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[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[Reference] = Field(
-        default=None, serialization_alias="sourcePortList", validation_alias="sourcePortList"
-    )
-    destination_ip: Union[IPv4Network, VariableName, None] = Field(
-        default=None, serialization_alias="destinationIP", validation_alias="destinationIP"
-    )
-    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[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[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(
-        default=None, serialization_alias="destinationPortList", validation_alias="destinationPortList"
-    )
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    @model_validator(mode="after")
-    def check_exclusive_fields(self):
-        check_fields_exclusive(self.__dict__, {"source_security_group", "source_ip", "source_data_prefix_list"}, False)
-        check_fields_exclusive(self.__dict__, {"source_security_group", "source_fqdn", "source_fqdn_list"}, False)
-        check_fields_exclusive(
-            self.__dict__, {"source_security_group", "source_geo_location", "source_geo_location_list"}, False
-        )
-        check_fields_exclusive(self.__dict__, {"source_security_group", "source_port", "source_port_list"}, False)
-        check_fields_exclusive(
-            self.__dict__, {"destination_security_group", "destination_ip", "destination_data_prefix_list"}, False
-        )
-        check_fields_exclusive(
-            self.__dict__, {"destination_security_group", "destination_fqdn", "destination_fqdn_list"}, False
-        )
-        check_fields_exclusive(
-            self.__dict__,
-            {"destination_security_group", "destination_geo_location", "destination_geo_location_list"},
-            False,
-        )
-        check_fields_exclusive(
-            self.__dict__, {"destination_security_group", "destination_port", "destination_port_list"}, False
-        )
-        return self
-
-
-class IPv6Rule(RuleBase):
-    sequence_ip_type: Literal["ipv6"] = Field(
-        default="ipv6", serialization_alias="sequenceIpType", validation_alias="sequenceIpType"
-    )
-    source_ipv6: Union[IPv6Network, VariableName, None] = Field(
-        default=None, serialization_alias="sourceIPV6", validation_alias="sourceIPV6"
-    )
-    source_ipv6_data_prefix_list: Optional[Reference] = Field(
-        default=None, serialization_alias="sourceIPV6DataPrefixList", validation_alias="sourceIPV6DataPrefixList"
-    )
-    destination_ipv6: Union[IPv6Network, VariableName, None] = Field(
-        default=None, serialization_alias="destinationIPV6", validation_alias="destinationIPV6"
-    )
-    destination_ipv6_data_prefix_list: Optional[Reference] = Field(
-        default=None,
-        serialization_alias="destinationIPV6DataPrefixList",
-        validation_alias="destinationIPV6DataPrefixList",
-    )
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    @model_validator(mode="after")
-    def check_exclusive_fields(self):
-        check_fields_exclusive(
-            self.__dict__, {"source_security_group", "source_ipv6", "source_ipv6_data_prefix_list"}, False
-        )
-        check_fields_exclusive(
-            self.__dict__,
-            {"destination_security_group", "destination_ipv6", "destination_ipv6_data_prefix_list"},
-            False,
-        )
-        return self
-
-
-Rule = Union[IPv4Rule, IPv6Rule]
-
-
-class RuleSetDefinition(BaseModel):
-    rules: List[Rule] = []
-
-
-class RuleSet(PolicyDefinitionBase):
-    type: Literal["ruleSet"] = "ruleSet"
-    definition: RuleSetDefinition = RuleSetDefinition()
-
-    def _enumerate_rules(self, from_index: int = 0) -> None:
-        """Updates rules entries with appropriate order and rule values.
-
-        Args:
-            from_index (int, optional): Only rules after that index in table will be updated. Defaults to 0.
-        """
-        start_index = from_index
-        rule_count = len(self.definition.rules)
-        if from_index < 0:
-            start_index = rule_count - start_index
-        for i in range(start_index, rule_count):
-            order = str(i + 1)
-            self.definition.rules[i].order = order
-            self.definition.rules[i].rule = f"R{order}"
-
-    def pop(self, index: int = -1) -> None:
-        """Removes a rule at given index, consecutive rules will be enumarated again.
-
-        Args:
-            index (int, optional): Defaults to -1.
-        """
-        self.definition.rules.pop(index)
-        self._enumerate_rules(index)
-
-    def add(self, rule: Rule) -> None:
-        """Adds new rule as last in table, order and rule fields will be autogenerated.
-
-        Args:
-            rule (Rule)
-        """
-        insert_index = len(self.definition.rules)
-        self.definition.rules.append(rule)
-        self._enumerate_rules(insert_index)
-
-    def add_ipv4_rule(
-        self,
-        action: str = "permit",
-        source_security_group_id: Optional[UUID] = None,
-        source_ip: Optional[IPv4Network] = None,
-        source_ip_variable: Optional[str] = None,
-        source_data_prefix_list_id: Optional[UUID] = None,
-        source_fqdn: Optional[str] = None,
-        source_fqdn_list_id: Optional[UUID] = None,
-        source_geo_location: Optional[str] = None,
-        source_geo_location_list_id: Optional[UUID] = None,
-        source_port: Optional[str] = None,
-        source_port_list_id: Optional[UUID] = None,
-        destination_security_group_id: Optional[UUID] = None,
-        destination_ip: Optional[IPv4Network] = None,
-        destination_ip_variable: Optional[str] = None,
-        destination_data_prefix_list_id: Optional[UUID] = None,
-        destination_fqdn: Optional[str] = None,
-        destination_fqdn_list_id: Optional[UUID] = None,
-        destination_geo_location: Optional[str] = None,
-        destination_geo_location_list_id: Optional[UUID] = None,
-        destination_port: Optional[str] = None,
-        destination_port_list_id: Optional[UUID] = None,
-        protocols: Optional[List[int]] = None,
-        protocol_names: Optional[str] = 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")
-        if destination_ip is not None and destination_ip_variable is not None:
-            raise ValueError("Destination IP and variable name cannot be set at the same time")
-        ipv4_rule = IPv4Rule(
-            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_fqdn=source_fqdn,
-            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=Reference(ref=source_geo_location_list_id)
-            if source_geo_location_list_id
-            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,
-            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_fqdn=destination_fqdn,
-            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=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_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=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/security_group.py

@@ -1,93 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from ipaddress import IPv4Network, IPv6Network
-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,
-)
-
-SequenceIPType = Literal[
-    "ipv4",
-    "ipv6",
-]
-
-
-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"
-    )
-    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"
-    )
-    port: Optional[str] = None
-    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")
-    def check_exclusive_fields(self):
-        check_any_of_exclusive_field_sets(
-            self.__dict__,
-            [
-                ({"data_prefix", "data_prefix_list"}, False),
-                ({"fqdn", "fqdn_list"}, False),
-                ({"geo_location", "geo_location_list"}, False),
-                ({"port", "port_list"}, False),
-            ],
-        )
-        return self
-
-
-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"
-    )
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    @model_validator(mode="after")
-    def check_exclusive_fields(self):
-        check_fields_exclusive(self.__dict__, {"data_ipv6_prefix", "data_ipv6_prefix_list"}, True)
-        return self
-
-
-class SecurityGroup(PolicyDefinitionBase):
-    # TODO: cannot use sequence_ip_type discriminated unions here as this is root of model
-    # 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"
-    )
-    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)
-        ):
-            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

@@ -1,37 +0,0 @@
-# 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