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

catalystwan/models/configuration/feature_profile/sdwan/service/route_policy.py

@@ -1,419 +1,171 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
 
-from ipaddress import IPv4Address, IPv6Address
 from typing import List, Literal, Optional, Union
 from uuid import UUID
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import (
-    Default,
-    Global,
-    Variable,
-    _ParcelBase,
-    as_default,
-    as_global,
-    as_variable,
-)
-from catalystwan.models.common import AcceptRejectActionType
-from catalystwan.models.configuration.feature_profile.common import RefIdItem
+from catalystwan.api.configuration_groups.parcel import Default, Global
 
-Community = Literal["internet", "local-AS", "no-advertise", "no-export"]
-Criteria = Literal["OR", "AND", "EXACT"]
-Protocol = Literal["IPV4", "IPV6", "BOTH"]
-MetricType = Literal["type1", "type2"]
-Origin = Literal["EGP", "IGP", "Incomplete"]
+Action = Literal[
+    "reject",
+    "accept",
+]
+
+Protocol = Literal[
+    "IPV4",
+    "IPV6",
+    "BOTH",
+]
+
+Criteria = Literal[
+    "or",
+    "and",
+    "exact",
+]
+
+MetricType = Literal[
+    "type1",
+    "type2",
+]
+
+Origin = Literal[
+    "egp",
+    "igp",
+    "incomplete",
+]
 
 
 class StandardCommunityList(BaseModel):
-    """
-    Community List
-    """
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    criteria: Union[Global[Criteria], Default[Criteria]] = Field(
-        default=as_default("OR", Criteria), description="Select a condition such as OR, AND or EXACT"
+    criteria: Union[Global[Criteria], Default[Criteria]] = Default[Criteria](value="or")
+    standard_community_list: List[Global[UUID]] = Field(
+        serialization_alias="standardCommunityList", validation_alias="standardCommunityList"
     )
-    standard_community_list: List[RefIdItem] = Field(
-        ...,
-        serialization_alias="standardCommunityList",
-        validation_alias="standardCommunityList",
-        description="Select a standard community list",
-        min_length=1,
-    )
-
-    @classmethod
-    def create(cls, standard_community_list: List[UUID], criteria: Criteria = "OR") -> StandardCommunityList:
-        return cls(
-            standard_community_list=[RefIdItem.from_uuid(i) for i in standard_community_list],
-            criteria=as_global(criteria, Criteria),
-        )
 
 
 class ExpandedCommunityList(BaseModel):
-    """
-    Community List
-    """
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    expanded_community_list: RefIdItem = Field(
-        ...,
-        serialization_alias="expandedCommunityList",
-        validation_alias="expandedCommunityList",
-        description="Select a expanded community list",
+    expanded_community_list: Global[UUID] = Field(
+        serialization_alias="expandedCommunityList", validation_alias="expandedCommunityList"
     )
 
-    @classmethod
-    def create(cls, expanded_community_list: UUID) -> ExpandedCommunityList:
-        return cls(expanded_community_list=RefIdItem.from_uuid(expanded_community_list))
 
+class RoutePolicyMatch(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-class MatchEntry(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    as_path_list: Optional[RefIdItem] = Field(
-        default=None, serialization_alias="asPathList", validation_alias="asPathList", description="As Path List"
+    as_path_list: Optional[Global[UUID]] = Field(
+        serialization_alias="asPathList", validation_alias="asPathList", default=None
     )
     community_list: Optional[Union[StandardCommunityList, ExpandedCommunityList]] = Field(
-        default=None,
-        serialization_alias="communityList",
-        validation_alias="communityList",
-        description="Community List",
+        serialization_alias="communityList", validation_alias="communityList", default=None
     )
-    ext_community_list: Optional[RefIdItem] = Field(
-        default=None,
-        serialization_alias="extCommunityList",
-        validation_alias="extCommunityList",
-        description="Extended Community List",
+    ext_community_list: Optional[Global[UUID]] = Field(
+        serialization_alias="extCommunityList", validation_alias="extCommunityList", default=None
     )
     bgp_local_preference: Optional[Global[int]] = Field(
-        default=None,
-        serialization_alias="bgpLocalPreference",
-        validation_alias="bgpLocalPreference",
-        description="BGP Local Preference",
-    )
-    metric: Optional[Global[int]] = Field(default=None, description="Select Metric")
-    omp_tag: Optional[Global[int]] = Field(
-        default=None, serialization_alias="ompTag", validation_alias="ompTag", description="Select OMP Tag"
+        serialization_alias="bgpLocalPreference", validation_alias="bgpLocalPreference", default=None
     )
-    ospf_tag: Optional[Global[int]] = Field(
-        default=None, serialization_alias="ospfTag", validation_alias="ospfTag", description="Select OSPF Tag"
+    metric: Optional[Global[int]] = None
+    omp_tag: Optional[Global[int]] = Field(serialization_alias="ompTag", validation_alias="ompTag", default=None)
+    ospf_tag: Optional[Global[int]] = Field(serialization_alias="ospfTag", validation_alias="ospfTag", default=None)
+    ipv4_address: Optional[Global[UUID]] = Field(
+        serialization_alias="ipv4Address", validation_alias="ipv4Address", default=None
     )
-    ipv4_address: Optional[RefIdItem] = Field(
-        default=None, serialization_alias="ipv4Address", validation_alias="ipv4Address", description="Ipv4 Address"
+    ipv4_nexthop: Optional[Global[UUID]] = Field(
+        serialization_alias="ipv4NextHop", validation_alias="ipv4NextHop", default=None
     )
-    ipv4_next_hop: Optional[RefIdItem] = Field(
-        default=None, serialization_alias="ipv4NextHop", validation_alias="ipv4NextHop", description="Ipv4 Next Hop"
+    ipv6_address: Optional[Global[UUID]] = Field(
+        serialization_alias="ipv6Address", validation_alias="ipv6Address", default=None
     )
-    ipv6_address: Optional[RefIdItem] = Field(
-        default=None, serialization_alias="ipv6Address", validation_alias="ipv6Address", description="Ipv6 Address"
-    )
-    ipv6_next_hop: Optional[RefIdItem] = Field(
-        default=None, serialization_alias="ipv6NextHop", validation_alias="ipv6NextHop", description="Ipv6 Next Hop"
+    ipv6_nexthop: Optional[Global[UUID]] = Field(
+        serialization_alias="ipv6NextHop", validation_alias="ipv6NextHop", default=None
     )
 
 
-class SetAsPath(BaseModel):
-    """
-    Set AS Path
-    """
+class AcceptAction(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    model_config = ConfigDict(
-        populate_by_name=True,
+    enable_accept_action: Default[bool] = Default[bool](value=True)
+    set_as_path: Optional[Global[int]] = Field(
+        serialization_alias="setAsPath", validation_alias="setAsPath", default=None
     )
-    prepend: Optional[List[Global[int]]] = None
-
-    @classmethod
-    def from_list(cls, prepend: List[int]) -> SetAsPath:
-        return cls(prepend=[as_global(i) for i in prepend])
-
-
-class SetCommunity(BaseModel):
-    """
-    Set Community
-    """
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-    )
-    additive: Union[Global[bool], Default[bool]] = as_default(False)
-    community: Optional[Union[Global[List[str]], Variable]] = None
-
-
-class Accept(BaseModel):
-    """
-    Accept Action
-    """
-
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
+    set_community: Optional[Union[Global[bool], Default[bool]]] = Field(
+        serialization_alias="setCommunity", validation_alias="setCommunity", default=None
     )
-    enable_accept_action: Default[bool] = Field(
-        default=as_default(True),
-        serialization_alias="enableAcceptAction",
-        validation_alias="enableAcceptAction",
-        description="Enable Accept Action",
+    set_local_preference: Optional[Global[int]] = Field(
+        serialization_alias="setLocalPreference", validation_alias="setLocalPreference", default=None
     )
-    as_path: Optional[SetAsPath] = Field(
-        default=None, serialization_alias="setAsPath", validation_alias="setAsPath", description="Set AS Path"
+    set_metric: Optional[Global[int]] = Field(
+        serialization_alias="setMetric", validation_alias="setMetric", default=None
     )
-    community: Optional[SetCommunity] = Field(
-        default=None, serialization_alias="setCommunity", validation_alias="setCommunity", description="Set Community"
+    set_metric_type: Optional[Global[MetricType]] = Field(
+        serialization_alias="setMetricType", validation_alias="setMetricType", default=None
     )
-    local_preference: Optional[Global[int]] = Field(
-        default=None,
-        serialization_alias="setLocalPreference",
-        validation_alias="setLocalPreference",
-        description="Set Local Preference",
+    set_omp_tag: Optional[Global[int]] = Field(
+        serialization_alias="setOmpTag", validation_alias="setOmpTag", default=None
     )
-    metric: Optional[Global[int]] = Field(
-        default=None, serialization_alias="setMetric", validation_alias="setMetric", description="Set Metric"
+    set_origin: Optional[Global[Origin]] = Field(
+        serialization_alias="setOrigin", validation_alias="setOrigin", default=None
     )
-    metric_type: Optional[Global[MetricType]] = Field(
-        default=None,
-        serialization_alias="setMetricType",
-        validation_alias="setMetricType",
-        description="Set Metric Type",
+    set_ospf_tag: Optional[Global[int]] = Field(
+        serialization_alias="setOspfTag", validation_alias="setOspfTag", default=None
     )
-    omp_tag: Optional[Global[int]] = Field(
-        default=None, serialization_alias="setOmpTag", validation_alias="setOmpTag", description="Set OMP Tag"
+    set_weight: Optional[Global[int]] = Field(
+        serialization_alias="setWeight", validation_alias="setWeight", default=None
     )
-    origin: Optional[Global[Origin]] = Field(
-        default=None, serialization_alias="setOrigin", validation_alias="setOrigin", description="Set Origin"
+    set_ipv4_nexthop: Optional[Global[str]] = Field(
+        serialization_alias="setIpv4NextHop", validation_alias="setIpv4NextHop", default=None
     )
-    ospf_tag: Optional[Global[int]] = Field(
-        default=None, serialization_alias="setOspfTag", validation_alias="setOspfTag", description="Set OSPF Tag"
-    )
-    weight: Optional[Global[int]] = Field(
-        default=None, serialization_alias="setWeight", validation_alias="setWeight", description="Set Weight"
-    )
-    ipv4_next_hop: Optional[Global[IPv4Address]] = Field(
-        default=None,
-        serialization_alias="setIpv4NextHop",
-        validation_alias="setIpv4NextHop",
-        description="Set Ipv4 Next Hop",
-    )
-    ipv6_next_hop: Optional[Global[IPv6Address]] = Field(
-        default=None,
-        serialization_alias="setIpv6NextHop",
-        validation_alias="setIpv6NextHop",
-        description="Set Ipv6 Next Hop",
+    set_ipv6_nexthop: Optional[Global[str]] = Field(
+        serialization_alias="setIpv6NextHop", validation_alias="setIpv6NextHop", default=None
     )
 
 
 class AcceptActions(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    accept: Accept = Field(..., description="Accept Action")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    accept: AcceptAction
 
 
 class RejectActions(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    reject: Default[bool] = Field(as_default(True), description="Reject Action")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    reject: Default[bool] = Default[bool](value=True)
 
 
 class RoutePolicySequence(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    sequence_id: Global[int] = Field(
-        ..., serialization_alias="sequenceId", validation_alias="sequenceId", description="Sequence Id"
-    )
-    sequence_name: Global[str] = Field(
-        ..., serialization_alias="sequenceName", validation_alias="sequenceName", description="Sequence Name"
-    )
-    base_action: Union[Global[AcceptRejectActionType], Default[AcceptRejectActionType]] = Field(
-        default=as_default("reject", AcceptRejectActionType),
-        serialization_alias="baseAction",
-        validation_alias="baseAction",
-        description="Base Action",
-    )
-    protocol: Union[Global[Protocol], Default[Protocol]] = Field(
-        default=as_default("IPV4", Protocol), description="protocol such as IPV4, IPV6, or BOTH"
-    )
-    match_entries: Optional[List[MatchEntry]] = Field(
-        default=None,
-        serialization_alias="matchEntries",
-        validation_alias="matchEntries",
-        description="Define match conditions",
-        max_length=1,
-        min_length=1,
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    sequence_id: Global[int] = Field(serialization_alias="sequenceId", validation_alias="sequenceId")
+    sequence_name: Global[str] = Field(serialization_alias="sequenceName", validation_alias="sequenceName")
+    base_action: Union[Global[Action], Default[Action]] = Field(
+        serialization_alias="baseAction", validation_alias="baseAction", default=Default[Action](value="reject")
     )
-    actions: Optional[List[Union[AcceptActions, RejectActions]]] = Field(
-        default=None, description="Define list of actions", max_length=1, min_length=1
+    protocol: Union[Global[Protocol], Default[Protocol]] = Default[Protocol](value="IPV4")
+    match_entries: Optional[List[RoutePolicyMatch]] = Field(
+        serialization_alias="matchEntries", validation_alias="matchEntries", default=None
     )
+    actions: Optional[List[Union[AcceptActions, RejectActions]]] = None
 
-    @property
-    def _action(self) -> Union[AcceptActions, RejectActions]:
-        if self.actions is None:
-            if self.base_action is None:
-                self.base_action = Global[AcceptRejectActionType](value="accept")
-            if self.base_action.value == "accept":
-                self.actions = [(AcceptActions(accept=Accept()))]
-            else:
-                self.actions = [(RejectActions(reject=as_default(True)))]
-        return self.actions[0]
-
-    @property
-    def _accept_action(self) -> Accept:
-        action = self._action
-        assert isinstance(action, AcceptActions), "Sequence action must be set to accept"
-        return action.accept
 
-    @property
-    def _entry(self) -> MatchEntry:
-        if self.match_entries is None:
-            self.match_entries = [MatchEntry()]
-        return self.match_entries[0]
-
-    def match_as_path_list(self, as_path_list: UUID) -> None:
-        self._entry.as_path_list = RefIdItem.from_uuid(as_path_list)
-
-    def match_community_list(
-        self,
-        expanded_community_list: Optional[UUID] = None,
-        standard_community_list: Optional[List[UUID]] = None,
-        criteria: Criteria = "OR",
-    ) -> None:
-        if expanded_community_list and standard_community_list:
-            raise ValueError("Only one community list should be set")
-
-        if expanded_community_list:
-            self._entry.community_list = ExpandedCommunityList.create(expanded_community_list)
-
-        if standard_community_list:
-            self._entry.community_list = StandardCommunityList.create(standard_community_list, criteria)
-
-    def match_ext_community_list(self, ext_community_list: UUID) -> None:
-        self._entry.ext_community_list = RefIdItem.from_uuid(ext_community_list)
-
-    def match_bgp_local_preference(self, bgp_local_preference: int) -> None:
-        self._entry.bgp_local_preference = as_global(bgp_local_preference)
-
-    def match_metric(self, metric: int) -> None:
-        self._entry.metric = as_global(metric)
-
-    def match_omp_tag(self, omp_tag: int) -> None:
-        self._entry.omp_tag = as_global(omp_tag)
-
-    def match_ospf_tag(self, ospf_tag: int) -> None:
-        self._entry.ospf_tag = as_global(ospf_tag)
-
-    def match_ipv4_address(self, ipv4_address: UUID) -> None:
-        self._entry.ipv4_address = RefIdItem.from_uuid(ipv4_address)
-
-    def match_ipv4_next_hop(self, ipv4_next_hop: UUID) -> None:
-        self._entry.ipv4_next_hop = RefIdItem.from_uuid(ipv4_next_hop)
-
-    def match_ipv6_address(self, ipv6_address: UUID) -> None:
-        self._entry.ipv6_address = RefIdItem.from_uuid(ipv6_address)
-
-    def match_ipv6_next_hop(self, ipv6_next_hop: UUID) -> None:
-        self._entry.ipv6_next_hop = RefIdItem.from_uuid(ipv6_next_hop)
-
-    def associate_reject_action(self) -> None:
-        self.actions = [(RejectActions(reject=as_default(True)))]
-
-    def associate_as_path_action(self, prepend: List[int]) -> None:
-        self._accept_action.as_path = SetAsPath.from_list(prepend)
-
-    def associate_communities_action(self, additive: bool, communities: List[str]) -> None:
-        set_community = SetCommunity(additive=as_global(additive), community=as_global(communities))
-        self._accept_action.community = set_community
-
-    def associate_community_variable_action(self, additive: bool, community: str) -> None:
-        set_community = SetCommunity(additive=as_global(additive), community=as_variable(community))
-        self._accept_action.community = set_community
-
-    def associate_local_preference_action(self, preference: int) -> None:
-        self._accept_action.local_preference = as_global(preference)
-
-    def associate_metric_action(self, set_metric: int) -> None:
-        self._accept_action.metric = as_global(set_metric)
-
-    def associate_metric_type_action(self, set_metric_type: MetricType) -> None:
-        self._accept_action.metric_type = as_global(set_metric_type, MetricType)
-
-    def associate_omp_tag_action(self, set_omp_tag: int) -> None:
-        self._accept_action.omp_tag = as_global(set_omp_tag)
-
-    def associate_origin_action(self, set_origin: Origin) -> None:
-        self._accept_action.origin = as_global(set_origin, Origin)
-
-    def associate_ospf_tag_action(self, set_ospf_tag: int) -> None:
-        self._accept_action.ospf_tag = as_global(set_ospf_tag)
-
-    def associate_weight_action(self, set_weight: int) -> None:
-        self._accept_action.weight = as_global(set_weight)
-
-    def associate_ipv4_next_hop_action(self, set_ipv4_next_hop: IPv4Address) -> None:
-        self._accept_action.ipv4_next_hop = as_global(set_ipv4_next_hop)
-
-    def associate_ipv6_next_hop_action(self, set_ipv6_next_hop: IPv6Address) -> None:
-        self._accept_action.ipv6_next_hop = as_global(set_ipv6_next_hop)
+class RoutePolicyData(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    @classmethod
-    def create(
-        cls,
-        sequence_id: int,
-        sequence_name: str,
-        base_action: AcceptRejectActionType = "reject",
-        protocol: Protocol = "IPV4",
-        match_entries: Optional[List[MatchEntry]] = None,
-        actions: Optional[List[Union[AcceptActions, RejectActions]]] = None,
-    ) -> RoutePolicySequence:
-        return cls(
-            sequence_id=as_global(sequence_id),
-            sequence_name=as_global(sequence_name),
-            base_action=as_global(base_action, AcceptRejectActionType),
-            protocol=as_global(protocol, Protocol),
-            match_entries=match_entries,
-            actions=actions,
-        )
+    defautl_action: Union[Global[Action], Default[Action]] = Field(
+        serialization_alias="defaultAction",
+        validation_alias="defaultAction",
+        default=Default[Action](value="reject"),
+    )
+    sequences: List[RoutePolicySequence] = []
 
 
-class RoutePolicyParcel(_ParcelBase):
-    type_: Literal["route-policy"] = Field(default="route-policy", exclude=True)
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    default_action: Union[Global[AcceptRejectActionType], Default[AcceptRejectActionType]] = Field(
-        default=as_default("reject", AcceptRejectActionType),
-        validation_alias=AliasPath("data", "defaultAction"),
-        description="Default Action",
-    )
-    sequences: List[RoutePolicySequence] = Field(
-        default_factory=list, validation_alias=AliasPath("data", "sequences"), description="Route Policy List"
-    )
+class RoutePolicyCreationPayload(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    def set_default_action(self, default_action: AcceptRejectActionType):
-        self.default_action = Global[AcceptRejectActionType](value=default_action)
-
-    def add_sequence(
-        self, id_: int, name: str, base_action: AcceptRejectActionType, protocol: Protocol
-    ) -> RoutePolicySequence:
-        sequence = RoutePolicySequence(
-            sequence_id=as_global(id_),
-            sequence_name=as_global(name),
-            base_action=as_global(base_action, AcceptRejectActionType),
-            protocol=as_global(protocol, Protocol),
-        )
-        self.sequences.append(sequence)
-        return sequence
+    name: str
+    description: Optional[str] = None
+    data: RoutePolicyData
+    metadata: Optional[dict] = None

catalystwan/models/configuration/feature_profile/sdwan/service/service_insertion_attachment.py

@@ -3,9 +3,9 @@
 from typing import List, Literal, Optional, Union
 from uuid import UUID
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field
 
-from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable
 
 AttachmentType = Literal[
     "custom",
@@ -53,7 +53,7 @@ ServiceType = Literal[
 
 
 class GatewayInterface(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     interface_name: Optional[Union[Global[str], Variable]] = Field(
         serialization_alias="gatewayInterfaceName", validation_alias="gatewayInterfaceName", default=None
@@ -67,7 +67,7 @@ class GatewayInterface(BaseModel):
 
 
 class ServiceInterface(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     interface_name: Optional[Union[Global[str], Variable]] = Field(
         serialization_alias="serviceInterfaceName", validation_alias="serviceInterfaceName", default=None
@@ -81,14 +81,14 @@ class ServiceInterface(BaseModel):
 
 
 class TrackingIP(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     ipv4: Optional[Union[Global[str], Variable]] = None
     ipv6: Optional[Union[Global[str], Variable]] = None
 
 
 class ReachableInterface(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     type: Global[ReachableInterfaceType] = Field(
         serialization_alias="reachableInterfaceType", validation_alias="reachableInterfaceType"
@@ -114,7 +114,7 @@ class ReachableInterface(BaseModel):
 
 
 class InterfaceProperties(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     gateway_interface: Optional[GatewayInterface] = Field(
         serialization_alias="gatewayInterface", validation_alias="gatewayInterface", default=None
@@ -134,7 +134,7 @@ class InterfaceProperties(BaseModel):
 
 
 class Attachment(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     interface_properties: List[InterfaceProperties] = Field(
         serialization_alias="interfaceProperties", validation_alias="interfaceProperties"
@@ -145,7 +145,7 @@ class Attachment(BaseModel):
 
 
 class TrackConfig(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     interval: Optional[Union[Global[int], Variable]] = None
     threshold: Optional[Union[Global[int], Variable]] = None
@@ -153,7 +153,7 @@ class TrackConfig(BaseModel):
 
 
 class Service(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     service_type: Union[Global[ServiceType], Variable] = Field(
         serialization_alias="serviceType", validation_alias="serviceType"
@@ -168,17 +168,25 @@ class Service(BaseModel):
     attachments: Optional[List[Attachment]] = None
 
 
-class ServiceInsertionAttachmentParcel(_ParcelBase):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+class ServiceInsertionAttachmentData(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
     attachment_type: Optional[Union[Global[AttachmentType], Variable]] = Field(
-        validation_alias=AliasPath("data", "attachmentType"), default=None
+        serialization_alias="attachmentType", validation_alias="attachmentType", default=None
     )
     service_chain_instance_id: Optional[Union[Global[str], Variable]] = Field(
-        validation_alias=AliasPath("data", "serviceChainInstanceID"), default=None
+        serialization_alias="serviceChainInstanceID", validation_alias="serviceChainInstanceID", default=None
     )
     service_chain_definition_id: Global[UUID] = Field(
-        validation_alias=AliasPath("data", "serviceChainDefinitionID"),
+        serialization_alias="serviceChainDefinitionID", validation_alias="serviceChainDefinitionID"
     )
-    vpn: Union[Global[int], Variable] = Field(validation_alias=AliasPath("data", "vpn"))
-    services: Optional[List[Service]] = Field(default=None, validation_alias=AliasPath("data", "services"))
+    vpn: Union[Global[int], Variable]
+    services: Optional[List[Service]] = None
+
+
+class ServiceInsertionAttachmentCreationPayload(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    name: str
+    description: Optional[str] = None
+    data: ServiceInsertionAttachmentData