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

catalystwan/models/configuration/feature_profile/sdwan/service/lan/common.py

@@ -1,81 +1,17 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import Literal, Optional, Union
+from ipaddress import IPv6Address, IPv6Interface
+from typing import Optional, Union
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from catalystwan.api.configuration_groups.parcel import Default, Global, Variable
-
-IkeMode = Literal[
-    "main",
-    "aggresive",
-]
-
-IkeCiphersuite = Literal[
-    "aes256-cbc-sha1",
-    "aes256-cbc-sha2",
-    "aes128-cbc-sha1",
-    "aes128-cbc-sha2",
-]
-
-IkeGroup = Literal[
-    "2",
-    "14",
-    "15",
-    "16",
-    "19",
-    "20",
-    "21",
-    "24",
-]
-
-IpsecCiphersuite = Literal[
-    "aes256-cbc-sha1",
-    "aes256-cbc-sha384",
-    "aes256-cbc-sha256",
-    "aes256-cbc-sha512",
-    "aes256-gcm",
-    "null-sha1",
-    "null-sha384",
-    "null-sha256",
-    "null-sha512",
-]
-
-PfsGroup = Literal[
-    "group-1",
-    "group-2",
-    "group-5",
-    "group-14",
-    "group-15",
-    "group-16",
-    "group-19",
-    "group-20",
-    "group-21",
-    "group-24",
-    "none",
-]
-
-TunnelApplication = Literal[
-    "none",
-    "sig",
-]
-
-VrrpTrackerAction = Literal[
-    "Decrement",
-    "Shutdown",
-]
-
-
-class Arp(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    ip_address: Union[Variable, Global[str], Default[None]]
-    mac_address: Union[Global[str], Variable]
+from catalystwan.models.common import VrrpTrackerAction
 
 
 class VrrpTrackingObject(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     tracker_id: Union[Default[None], Global[UUID]] = Field(
         serialization_alias="trackerId", validation_alias="trackerId"
@@ -89,26 +25,9 @@ class VrrpTrackingObject(BaseModel):
 
 
 class VrrpIPv6Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
-    ipv6_link_local: Union[Global[str], Variable] = Field(
+    ipv6_link_local: Union[Global[str], Global[IPv6Address], Variable] = Field(
         serialization_alias="ipv6LinkLocal", validation_alias="ipv6LinkLocal"
     )
-    prefix: Optional[Union[Global[str], Variable, Default[None]]] = None
-
-
-class StaticIPv4Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    ip_address: Union[Variable, Global[str], Default[None]] = Field(
-        serialization_alias="ipAddress", validation_alias="ipAddress"
-    )
-    subnet_mask: Union[Variable, Global[str], Default[None]] = Field(
-        serialization_alias="subnetMask", validation_alias="subnetMask"
-    )
-
-
-class StaticIPv6Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    address: Union[Global[str], Variable]
+    prefix: Optional[Union[Global[str], Global[IPv6Interface], Variable, Default[None]]] = None

catalystwan/models/configuration/feature_profile/sdwan/service/lan/ethernet.py

@@ -1,99 +1,159 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import List, Literal, Optional, Union
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, Field
+from ipaddress import IPv4Address
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import (
+    AliasPath,
+    BaseModel,
+    ConfigDict,
+    Field,
+    SerializationInfo,
+    SerializerFunctionWrapHandler,
+    model_serializer,
+)
+from typing_extensions import Annotated
 
-from catalystwan.api.configuration_groups.parcel import Default, Global, Variable
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.common import (
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase
+from catalystwan.models.common import EthernetDuplexMode, MediaType, VersionedField
+from catalystwan.models.configuration.feature_profile.common import (
     Arp,
+    DynamicDhcpDistance,
+    EthernetNatAttributesIpv4,
+    InterfaceDynamicIPv4Address,
+    InterfaceDynamicIPv6Address,
+    InterfaceStaticIPv4Address,
+    RefIdItem,
     StaticIPv4Address,
+    StaticIPv4AddressConfig,
     StaticIPv6Address,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.service.lan.common import (
     VrrpIPv6Address,
     VrrpTrackingObject,
 )
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.vpn import Direction
 
-NatType = Literal[
-    "pool",
-    "loopback",
+LoadBalance = Literal[
+    "flow",
+    "vlan",
 ]
 
-DuplexMode = Literal[
-    "full",
-    "half",
-    "auto",
+LacpMode = Literal[
+    "active",
+    "passive",
 ]
 
-MediaType = Literal[
-    "auto-select",
-    "rj45",
-    "sfp",
+
+LacpRate = Literal[
+    "fast",
+    "normal",
 ]
 
 
-class DynamicDhcpDistance(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+class PortChannelMemberLinksLacp(BaseModel):
+    lacp_mode: Union[Global[LacpMode], Default[Literal["active"]], Variable] = Field(
+        validation_alias="lacpMode", serialization_alias="lacpMode"
+    )
+    interface: Optional[RefIdItem] = Field(default=None)
+    lacp_port_priority: Optional[Union[Variable, Global[int], Default[None]]] = Field(
+        default=None, validation_alias="lacpPortPriority", serialization_alias="lacpPortPriority"
+    )
+    lacp_rate: Optional[Union[Variable, Global[LacpRate], Default[None]]] = Field(
+        default=None, validation_alias="lacpRate", serialization_alias="lacpRate"
+    )
 
-    dynamic_dhcp_distance: Union[Variable, Global[int], Default[int]] = Default[int](value=1)
 
+class LacpModeMainInterface(BaseModel):
+    port_channel_member_links: List[PortChannelMemberLinksLacp] = Field(
+        validation_alias="portChannelMemberLinks",
+        serialization_alias="portChannelMemberLinks",
+        description="Configure Port-Channel member links",
+    )
+    lacp_fast_switchover: Optional[Union[Global[bool], Default[bool], Variable]] = Field(
+        default=None, validation_alias="lacpFastSwitchover", serialization_alias="lacpFastSwitchover"
+    )
+    lacp_max_bundle: Optional[Union[Variable, Global[int], Default[None]]] = Field(
+        default=None, validation_alias="lacpMaxBundle", serialization_alias="lacpMaxBundle"
+    )
+    lacp_min_bundle: Optional[Union[Variable, Global[int], Default[None]]] = Field(
+        default=None, validation_alias="lacpMinBundle", serialization_alias="lacpMinBundle"
+    )
+    load_balance: Optional[Union[Variable, Global[LoadBalance], Default[None]]] = Field(
+        default=None, validation_alias="loadBalance", serialization_alias="loadBalance"
+    )
+    port_channel_qos_aggregate: Optional[Union[Global[bool], Default[bool], Variable]] = Field(
+        default=None, validation_alias="portChannelQosAggregate", serialization_alias="portChannelQosAggregate"
+    )
 
-class InterfaceDynamicIPv4Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    dynamic: DynamicDhcpDistance
+class MainInterfaceLcap(BaseModel):
+    lacp_mode_main_interface: LacpModeMainInterface = Field(
+        validation_alias="lacpModeMainInterface", serialization_alias="lacpModeMainInterface"
+    )
+
 
+class PortChannelMemberLinksMain(BaseModel):
+    interface: Optional[RefIdItem] = Field(default=None)
 
-class StaticIPv4AddressConfig(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    primary_ip_address: StaticIPv4Address = Field(
-        serialization_alias="staticIpV4AddressPrimary", validation_alias="staticIpV4AddressPrimary"
+class StaticModeMainInterface(BaseModel):
+    port_channel_member_links: List[PortChannelMemberLinksMain] = Field(
+        validation_alias="portChannelMemberLinks",
+        serialization_alias="portChannelMemberLinks",
+        description="Configure Port-Channel member links",
     )
-    secondary_ip_address: Optional[StaticIPv4Address] = Field(
-        serialization_alias="staticIpV4AddressSecondary", validation_alias="staticIpV4AddressSecondary", default=None
+    load_balance: Optional[Union[Variable, Global[LoadBalance], Default[None]]] = Field(
+        default=None, validation_alias="loadBalance", serialization_alias="loadBalance"
+    )
+    port_channel_qos_aggregate: Optional[Union[Global[bool], Default[bool], Variable]] = Field(
+        default=None, validation_alias="portChannelQosAggregate", serialization_alias="portChannelQosAggregate"
     )
 
 
-class InterfaceStaticIPv4Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+class MainInterfaceStatic(BaseModel):
+    static_mode_main_interface: StaticModeMainInterface = Field(
+        validation_alias="staticModeMainInterface", serialization_alias="staticModeMainInterface"
+    )
 
-    static: StaticIPv4AddressConfig
 
+MainInterface = Union[MainInterfaceLcap, MainInterfaceStatic]
 
-class DynamicIPv6Dhcp(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    dhcp_client: Global[dict] = Field(
-        serialization_alias="dhcpClient", validation_alias="dhcpClient", default=Global[dict](value={})
+class PortChannelMainIntf(BaseModel):
+    main_interface: MainInterface = Field(validation_alias="mainInterface", serialization_alias="mainInterface")
+
+
+class SubInterface(BaseModel):
+    primary_interface_name: Optional[Union[Global[str], Variable, Default[None]]] = Field(
+        default=None, validation_alias="primaryInterfaceName", serialization_alias="primaryInterfaceName"
     )
-    secondary_ipv6_address: Optional[List[StaticIPv6Address]] = Field(
-        serialization_alias="secondaryIpV6Address", validation_alias="secondaryIpV6Address"
+    secondary_interface_name: Optional[Union[Global[str], Variable, Default[None]]] = Field(
+        default=None, validation_alias="secondaryInterfaceName", serialization_alias="secondaryInterfaceName"
     )
 
 
-class InterfaceDynamicIPv6Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+class PortChannelSubIntf(BaseModel):
+    sub_interface: SubInterface = Field(validation_alias="subInterface", serialization_alias="subInterface")
+
 
-    dynamic: DynamicIPv6Dhcp
+PortChannel = Union[PortChannelSubIntf, PortChannelMainIntf]
 
 
 class Dhcpv6Helper(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     ip_address: Union[Global[str], Variable] = Field(serialization_alias="ipAddress", validation_alias="ipAddress")
     vpn: Optional[Union[Global[int], Variable, Default[None]]] = None
 
 
 class StaticIPv6AddressConfig(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     primary_ip_address: StaticIPv6Address = Field(
-        serialization_alias="staticIpV6AddressPrimary", validation_alias="staticIpV6AddressPrimary"
+        serialization_alias="primaryIpV6Address", validation_alias="primaryIpV6Address"
     )
     secondary_ip_address: Optional[List[StaticIPv6Address]] = Field(
-        serialization_alias="staticIpV6AddressSecondary", validation_alias="staticIpV6AddressSecondary", default=None
+        serialization_alias="secondaryIpV6Address", validation_alias="secondaryIpV6Address", default=None
     )
     dhcp_helper_v6: Optional[List[Dhcpv6Helper]] = Field(
         serialization_alias="dhcpHelperV6", validation_alias="dhcpHelperV6", default=None
@@ -101,91 +161,39 @@ class StaticIPv6AddressConfig(BaseModel):
 
 
 class InterfaceStaticIPv6Address(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     static: StaticIPv6AddressConfig
 
 
-class NatPool(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    range_start: Union[Variable, Global[str], Default[None]] = Field(
-        serialization_alias="rangeStart", validation_alias="rangeStart"
-    )
-    range_end: Union[Variable, Global[str], Default[None]] = Field(
-        serialization_alias="rangeEnd", validation_alias="rangeEnd"
-    )
-    prefix_length: Union[Variable, Global[int], Default[None]] = Field(
-        serialization_alias="prefixLength", validation_alias="prefixLength"
-    )
-    overload: Union[Variable, Global[bool], Default[bool]] = Default[bool](value=True)
-
-
-class StaticNat(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    source_ip: Union[Global[str], Variable] = Field(serialization_alias="sourceIp", validation_alias="sourceIp")
-
-    translate_ip: Union[Global[str], Variable] = Field(
-        serialization_alias="translateIp", validation_alias="translateIp"
-    )
-    static_nat_direction: Union[Global[Direction], Default[Direction]] = Field(
-        serialization_alias="staticNatDirection",
-        validation_alias="staticNatDirection",
-        default=Default[Direction](value="inside"),
-    )
-    source_vpn: Union[Global[int], Variable, Default[int]] = Field(
-        serialization_alias="sourceVpn", validation_alias="sourceVpn", default=Default[int](value=0)
-    )
-
-
-class NatAttributesIPv4(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    nat_type: Union[Global[NatType], Variable] = Field(serialization_alias="natType", validation_alias="natType")
-    nat_pool: Optional[NatPool] = Field(serialization_alias="natPool", validation_alias="natPool", default=None)
-    nat_loopback: Optional[Union[Global[str], Variable, Default[None]]] = Field(
-        serialization_alias="natLoopbakc", validation_alias="natLoopbakc", default=None
-    )
-    udp_timeout: Union[Global[int], Variable, Default[int]] = Field(
-        serialization_alias="udpTimeout", validation_alias="udpTimeout", default=Default[int](value=1)
-    )
-    tcp_timeout: Union[Global[int], Variable, Default[int]] = Field(
-        serialization_alias="tcpTimeout", validation_alias="tcpTimeout", default=Default[int](value=1)
-    )
-    new_static_nat: Optional[List[StaticNat]] = Field(
-        serialization_alias="newStaticNat", validation_alias="newStaticNat", default=None
-    )
-
-
 class NatAttributesIPv6(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     nat64: Optional[Union[Global[bool], Default[bool]]] = Default[bool](value=False)
 
 
 class AclQos(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     shaping_rate: Optional[Union[Global[int], Variable, Default[None]]] = Field(
         serialization_alias="shapingRate", validation_alias="shapingRate", default=None
     )
-    ipv4_acl_egress: Optional[Global[UUID]] = Field(
+    ipv4_acl_egress: Optional[RefIdItem] = Field(
         serialization_alias="ipv4AclEgress", validation_alias="ipv4AclEgress", default=None
     )
-    ipv4_acl_ingress: Optional[Global[UUID]] = Field(
+    ipv4_acl_ingress: Optional[RefIdItem] = Field(
         serialization_alias="ipv4AclIngress", validation_alias="ipv4AclIngress", default=None
     )
-    ipv6_acl_egress: Optional[Global[UUID]] = Field(
+    ipv6_acl_egress: Optional[RefIdItem] = Field(
         serialization_alias="ipv6AclEgress", validation_alias="ipv6AclEgress", default=None
     )
-    ipv6_acl_ingress: Optional[Global[UUID]] = Field(
+    ipv6_acl_ingress: Optional[RefIdItem] = Field(
         serialization_alias="ipv6AclIngress", validation_alias="ipv6AclIngress", default=None
     )
 
 
 class VrrpIPv6(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
     group_id: Union[Variable, Global[int]] = Field(serialization_alias="groupId", validation_alias="groupId")
     priority: Union[Variable, Global[int], Default[int]] = Default[int](value=100)
@@ -194,20 +202,32 @@ class VrrpIPv6(BaseModel):
         serialization_alias="trackOmp", validation_alias="trackOmp", default=Default[bool](value=False)
     )
     ipv6: List[VrrpIPv6Address]
+    follow_dual_router_h_a_availability: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None,
+        validation_alias="followDualRouterHAAvailability",
+        serialization_alias="followDualRouterHAAvailability",
+    )
+    min_preempt_delay: Optional[Union[Variable, Global[int], Default[None]]] = Field(
+        default=None, validation_alias="minPreemptDelay", serialization_alias="minPreemptDelay"
+    )
 
 
 class VrrpIPv4(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
-    group_id: Union[Variable, Global[int]] = Field(serialization_alias="groupId", validation_alias="groupId")
+    group_id: Union[Variable, Global[int]]
     priority: Union[Variable, Global[int], Default[int]] = Default[int](value=100)
     timer: Union[Variable, Global[int], Default[int]] = Default[int](value=1000)
     track_omp: Union[Global[bool], Default[bool]] = Field(
         serialization_alias="trackOmp", validation_alias="trackOmp", default=Default[bool](value=False)
     )
-    ip_address: Union[Global[str], Variable] = Field(serialization_alias="ipAddress", validation_alias="ipAddress")
+    ip_address: Union[Global[str], Global[IPv4Address], Variable] = Field(
+        serialization_alias="ipAddress", validation_alias="ipAddress"
+    )
     ip_address_secondary: Optional[List[StaticIPv4Address]] = Field(
-        serialization_alias="ipAddressSecondary", validation_alias="ipAddressSecondary"
+        serialization_alias="ipAddressSecondary",
+        validation_alias="ipAddressSecondary",
+        default=None,
     )
     tloc_pref_change: Union[Global[bool], Default[bool]] = Field(
         serialization_alias="tlocPrefChange", validation_alias="tlocPrefChange", default=Default[bool](value=False)
@@ -218,32 +238,54 @@ class VrrpIPv4(BaseModel):
     tracking_object: Optional[List[VrrpTrackingObject]] = Field(
         serialization_alias="trackingObject", validation_alias="trackingObject", default=None
     )
+    follow_dual_router_h_a_availability: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None,
+        validation_alias="followDualRouterHAAvailability",
+        serialization_alias="followDualRouterHAAvailability",
+    )
+    min_preempt_delay: Optional[Union[Variable, Global[int], Default[None]]] = Field(
+        default=None, validation_alias="minPreemptDelay", serialization_alias="minPreemptDelay"
+    )
+
+    @model_serializer(mode="wrap", when_used="json")
+    def serialize(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> Dict[str, Any]:
+        return VersionedField.dump(self.model_fields, handler(self), info)
 
 
 class Trustsec(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
-    enable_sgt_propagation: Union[Global[bool], Default[bool]] = Field(
-        serialization_alias="enableSGTPropagation",
-        validation_alias="enableSGTPropagation",
+    enable_sgt_propogation: Union[Global[bool], Default[bool]] = Field(
+        serialization_alias="enableSGTPropogation",
+        validation_alias="enableSGTPropogation",
         default=Default[bool](value=False),
     )
-    propogate: Optional[Union[Global[bool], Default[bool]]] = Default[bool](value=True)
+    propogate: Annotated[
+        Optional[Union[Global[bool], Default[bool]]], VersionedField(versions="<=20.12", forbidden=True)
+    ] = Default[bool](value=True)
     security_group_tag: Optional[Union[Global[int], Variable, Default[None]]] = Field(
         serialization_alias="securityGroupTag", validation_alias="securityGroupTag", default=None
     )
-    enable_enforced_propagation: Union[Global[bool], Default[None]] = Field(
-        serialization_alias="enableEnforcedPropagation", validation_alias="enableEnforcedPropagation"
+    enable_enforced_propogation: Union[Global[bool], Default[None]] = Field(
+        default=Default[None](value=None),
+        serialization_alias="enableEnforcedPropogation",
+        validation_alias="enableEnforcedPropogation",
     )
     enforced_security_group_tag: Union[Global[int], Variable, Default[None]] = Field(
-        serialization_alias="enforcedSecurityGroupTag", validation_alias="enforcedSecurityGroupTag"
+        default=Default[None](value=None),
+        serialization_alias="enforcedSecurityGroupTag",
+        validation_alias="enforcedSecurityGroupTag",
     )
 
+    @model_serializer(mode="wrap", when_used="json")
+    def serialize(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> Dict[str, Any]:
+        return VersionedField.dump(self.model_fields, handler(self), info)
+
 
-class AdvancedAttributes(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+class AdvancedEthernetAttributes(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
-    duplex: Optional[Union[Global[DuplexMode], Variable, Default[None]]] = None
+    duplex: Optional[Union[Global[EthernetDuplexMode], Variable, Default[None]]] = None
     mac_address: Optional[Union[Global[str], Variable, Default[None]]] = Field(
         serialization_alias="macAddress", validation_alias="macAddress", default=None
     )
@@ -251,7 +293,7 @@ class AdvancedAttributes(BaseModel):
         serialization_alias="ipMtu", validation_alias="ipMtu", default=Default[int](value=1500)
     )
     interface_mtu: Optional[Union[Global[int], Variable, Default[int]]] = Field(
-        serialization_alias="intrfMtu", validation_alias="intrfMtu", default=Default[int](value=1500)
+        default=None, serialization_alias="intrfMtu", validation_alias="intrfMtu"
     )
     tcp_mss: Optional[Union[Global[int], Variable, Default[int]]] = Field(
         serialization_alias="tcpMss", validation_alias="tcpMss", default=None
@@ -273,7 +315,7 @@ class AdvancedAttributes(BaseModel):
         validation_alias="icmpRedirectDisable",
         default=Default[bool](value=True),
     )
-    xconnect: Optional[Union[Global[str], Variable, Default[None]]] = None
+    xconnect: Optional[Union[Global[str], Global[IPv4Address], Variable, Default[None]]] = None
     ip_directed_broadcast: Union[Global[bool], Variable, Default[bool]] = Field(
         serialization_alias="ipDirectedBroadcast",
         validation_alias="ipDirectedBroadcast",
@@ -281,47 +323,81 @@ class AdvancedAttributes(BaseModel):
     )
 
 
-class InterfaceEthernetData(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+class InterfaceEthernetParcel(_ParcelBase):
+    type_: Literal["lan/vpn/interface/ethernet"] = Field(default="lan/vpn/interface/ethernet", exclude=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
 
-    shutdown: Union[Global[bool], Variable, Default[bool]] = Default[bool](value=True)
-    interface_name: Union[Global[str], Variable] = Field(
-        serialization_alias="interfaceName", validation_alias="interfaceName"
+    shutdown: Union[Global[bool], Variable, Default[bool]] = Field(
+        default=Default[bool](value=True), validation_alias=AliasPath("data", "shutdown")
+    )
+    interface_name: Union[Global[str], Variable] = Field(validation_alias=AliasPath("data", "interfaceName"))
+    ethernet_description: Optional[Union[Global[str], Variable, Default[None]]] = Field(
+        default=Default[None](value=None), validation_alias=AliasPath("data", "description")
     )
-    description: Optional[Union[Global[str], Variable, Default[None]]] = None
     interface_ip_address: Union[InterfaceDynamicIPv4Address, InterfaceStaticIPv4Address] = Field(
-        serialization_alias="intfIpAddress", validation_alias="intfIpAddress"
+        validation_alias=AliasPath("data", "intfIpAddress"), default_factory=InterfaceStaticIPv4Address
     )
     dhcp_helper: Optional[Union[Variable, Global[List[str]], Default[None]]] = Field(
-        serialization_alias="dhcpHelper", validation_alias="dhcpHelper", default=None
+        validation_alias=AliasPath("data", "dhcpHelper"), default=None
     )
     interface_ipv6_address: Optional[Union[InterfaceDynamicIPv6Address, InterfaceStaticIPv6Address]] = Field(
-        serialization_alias="intfIpV6Address", validation_alias="intfIpV6Address", default=None
+        validation_alias=AliasPath("data", "intfIpV6Address"), default=None
+    )
+    nat: Union[Global[bool], Default[bool]] = Field(
+        validation_alias=AliasPath("data", "nat"), default=Default[bool](value=False)
     )
-    nat: Union[Global[bool], Default[bool]] = Default[bool](value=False)
-    nat_attributes_ipv4: Optional[NatAttributesIPv4] = Field(
-        serialization_alias="natAttributesIpv4", validation_alias="natAttributesIpv4", default=None
+    nat_attributes_ipv4: Optional[EthernetNatAttributesIpv4] = Field(
+        validation_alias=AliasPath("data", "natAttributesIpv4"), default=None
     )
     nat_ipv6: Optional[Union[Global[bool], Default[bool]]] = Field(
-        serialization_alias="natIpv6", validation_alias="natIpv6", default=Default[bool](value=False)
+        validation_alias=AliasPath("data", "natIpv6"), default=Default[bool](value=False)
     )
     nat_attributes_ipv6: Optional[NatAttributesIPv6] = Field(
-        serialization_alias="natAttributesIpv6", validation_alias="natAttributesIpv6", default=None
-    )
-    acl_qos: Optional[AclQos] = Field(serialization_alias="aclQos", validation_alias="aclQos", default=None)
-    vrrp_ipv6: Optional[List[VrrpIPv6]] = Field(
-        serialization_alias="vrrpIpv6", validation_alias="vrrpIpv6", default=None
-    )
-    vrrp: Optional[List[VrrpIPv4]] = None
-    arp: Optional[List[Arp]] = None
-    trustsec: Optional[Trustsec] = None
-    advanced: AdvancedAttributes = AdvancedAttributes()
-
-
-class InterfaceEthernetCreationPayload(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    name: str
-    description: Optional[str] = None
-    data: InterfaceEthernetData
-    metadata: Optional[dict] = None
+        validation_alias=AliasPath("data", "natAttributesIpv6"), default=None
+    )
+    acl_qos: Optional[AclQos] = Field(validation_alias=AliasPath("data", "aclQos"), default=None)
+    vrrp_ipv6: Optional[List[VrrpIPv6]] = Field(validation_alias=AliasPath("data", "vrrpIpv6"), default=None)
+    vrrp: Optional[List[VrrpIPv4]] = Field(validation_alias=AliasPath("data", "vrrp"), default=None)
+    arp: Optional[List[Arp]] = Field(validation_alias=AliasPath("data", "arp"), default=None)
+    trustsec: Optional[Trustsec] = Field(validation_alias=AliasPath("data", "trustsec"), default=None)
+    advanced: AdvancedEthernetAttributes = Field(
+        validation_alias=AliasPath("data", "advanced"), default_factory=AdvancedEthernetAttributes
+    )
+    port_channel: Optional[PortChannel] = Field(default=None, validation_alias=AliasPath("data", "portChannel"))
+    port_channel_interface: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None, validation_alias=AliasPath("data", "portChannelInterface")
+    )
+    port_channel_member_interface: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None, validation_alias=AliasPath("data", "portChannelMemberInterface")
+    )
+
+    def set_dynamic_interface_ip_address(self, dhcp_distance: Union[Global[int], Variable]) -> None:
+        self.interface_ip_address = InterfaceDynamicIPv4Address(
+            dynamic=DynamicDhcpDistance(dynamic_dhcp_distance=dhcp_distance)
+        )
+
+    def set_static_primary_interface_ip_address(
+        self,
+        ip_address: Union[Global[str], Global[IPv4Address], Variable],
+        subnet_mask: Optional[Union[Global[str], Variable]] = None,
+    ) -> None:
+        if subnet_mask is None:
+            primary_ip_address = StaticIPv4Address(ip_address=ip_address)
+        else:
+            primary_ip_address = StaticIPv4Address(ip_address=ip_address, subnet_mask=subnet_mask)
+        self.interface_ip_address = InterfaceStaticIPv4Address(
+            static=StaticIPv4AddressConfig(primary_ip_address=primary_ip_address)
+        )
+
+    def add_static_secondary_interface_ip_address(
+        self, ip_address: Union[Global[str], Global[IPv4Address], Variable], subnet_mask: Union[Global[str], Variable]
+    ) -> None:
+        if self.interface_ip_address is None:
+            raise ValueError("Missing static primary IP Address")
+        if isinstance(self.interface_ip_address, InterfaceDynamicIPv4Address):
+            raise ValueError("Interface IP Address is already dynamic")
+
+        secondary_ip_address = StaticIPv4Address(ip_address=ip_address, subnet_mask=subnet_mask)
+        if self.interface_ip_address.static.secondary_ip_address is None:
+            self.interface_ip_address.static.secondary_ip_address = []
+        self.interface_ip_address.static.secondary_ip_address.append(secondary_ip_address)