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

catalystwan/models/configuration/feature_profile/sdwan/topology/custom_control.py

@@ -1,425 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from ipaddress import IPv4Address
-from typing import Any, Dict, List, Literal, Optional, overload
-from uuid import UUID
-
-from pydantic import (
-    AliasPath,
-    BaseModel,
-    ConfigDict,
-    Field,
-    SerializationInfo,
-    SerializerFunctionWrapHandler,
-    model_serializer,
-    model_validator,
-)
-from typing_extensions import Annotated
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
-from catalystwan.models.common import (
-    AcceptRejectActionType,
-    CarrierType,
-    ControlPathType,
-    EncapType,
-    MultiRegionRole,
-    OriginProtocol,
-    SequenceIpType,
-    ServiceChainNumber,
-    ServiceType,
-    TLOCActionType,
-    TLOCColor,
-    VersionedField,
-    check_fields_exclusive,
-)
-from catalystwan.models.configuration.feature_profile.common import RefIdItem
-
-Level = Literal[
-    "REGION",
-    "SITE",
-    "SUB_REGION",
-]
-
-ControlSequenceType = Literal[
-    "route",
-    "tloc",
-]
-
-
-class Region(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    region: Optional[Global[str]] = Field(default=None)
-    sub_region: Optional[Global[List[str]]] = Field(
-        default=None, validation_alias="subRegion", serialization_alias="subRegion"
-    )
-
-
-class Target(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    inbound_regions: Optional[List[Region]] = Field(
-        default=None, validation_alias="inboundRegions", serialization_alias="inboundRegions"
-    )
-    inbound_sites: Optional[Global[List[str]]] = Field(
-        default=None, validation_alias="inboundSites", serialization_alias="inboundSites"
-    )
-    level: Annotated[Optional[Global[Level]], VersionedField(versions="<20.15", forbidden=True)] = Field(default=None)
-    outbound_regions: Optional[List[Region]] = Field(
-        default=None, validation_alias="outboundRegions", serialization_alias="outboundRegions"
-    )
-    outbound_sites: Optional[Global[List[str]]] = Field(
-        default=None, validation_alias="outboundSites", serialization_alias="outboundSites"
-    )
-    vpn: Optional[Global[List[str]]] = Field(default=None)
-
-    @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 Tloc(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    color: Optional[Global[TLOCColor]] = Field(default=None)
-    encap: Optional[Global[EncapType]] = Field(default=None)
-    ip: Optional[Global[str]] = Field(default=None)
-
-    @staticmethod
-    def from_params(color: TLOCColor, encap: EncapType, ip: IPv4Address) -> "Tloc":
-        _color = as_global(color, TLOCColor)
-        _encap = as_global(encap, EncapType)
-        _ip = as_global(str(ip))
-        return Tloc(color=_color, encap=_encap, ip=_ip)
-
-
-class Entry(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    carrier: Optional[Global[CarrierType]] = Field(default=None)
-    color_list: Optional[RefIdItem] = Field(default=None, validation_alias="colorList", serialization_alias="colorList")
-    community: Optional[RefIdItem] = Field(default=None)
-    domain_id: Optional[Global[int]] = Field(default=None, validation_alias="domainId", serialization_alias="domainId")
-    expanded_community: Optional[RefIdItem] = Field(
-        default=None, validation_alias="expandedCommunity", serialization_alias="expandedCommunity"
-    )
-    group_id: Optional[Global[int]] = Field(default=None, validation_alias="groupId", serialization_alias="groupId")
-    ipv6prefix_list: Optional[RefIdItem] = Field(
-        default=None, validation_alias="ipv6prefixList", serialization_alias="ipv6prefixList"
-    )
-    omp_tag: Optional[Global[int]] = Field(default=None, validation_alias="ompTag", serialization_alias="ompTag")
-    origin: Optional[Global[OriginProtocol]] = Field(default=None)
-    originator: Optional[Global[str]] = Field(default=None)
-    path_type: Optional[Global[ControlPathType]] = Field(
-        default=None, validation_alias="pathType", serialization_alias="pathType"
-    )
-    preference: Optional[Global[int]] = Field(default=None)
-    prefix_list: Optional[RefIdItem] = Field(
-        default=None, validation_alias="prefixList", serialization_alias="prefixList"
-    )
-    regions: Optional[List[Region]] = Field(default=None)
-    role: Optional[Global[MultiRegionRole]] = Field(default=None)
-    site: Optional[Global[List[str]]] = Field(default=None)
-    tloc: Optional[Tloc] = Field(default=None)
-    tloc_list: Optional[RefIdItem] = Field(default=None, validation_alias="tlocList", serialization_alias="tlocList")
-    vpn: Optional[Global[List[str]]] = Field(default=None)
-
-
-class Match(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    entries: List[Entry] = Field()
-
-
-class Service(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    tloc: Optional[Tloc] = Field(default=None)
-    tloc_list: Optional[RefIdItem] = Field(default=None, validation_alias="tlocList", serialization_alias="tlocList")
-    type: Optional[Global[ServiceType]] = Field(default=None)
-    vpn: Optional[Global[int]] = Field(default=None)
-
-    @model_validator(mode="after")
-    def tloc_xor_tloc_list(self):
-        check_fields_exclusive(self.__dict__, {"tloc", "tloc_list"}, True)
-        return self
-
-
-class ServiceChain(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    tloc: Optional[Tloc] = Field(default=None)
-    tloc_list: Optional[RefIdItem] = Field(default=None, validation_alias="tlocList", serialization_alias="tlocList")
-    type: Optional[Global[ServiceChainNumber]] = Field(default=None)
-    vpn: Optional[Global[int]] = Field(default=None)
-
-    @model_validator(mode="after")
-    def tloc_nand_tloc_list(self):
-        check_fields_exclusive(self.__dict__, {"tloc", "tloc_list"}, False)
-        return self
-
-
-class ActionSet(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    affinity: Optional[Global[int]] = Field(default=None)
-    community: Optional[Global[str]] = Field(default=None)
-    community_additive: Optional[Global[bool]] = Field(
-        default=None, validation_alias="communityAdditive", serialization_alias="communityAdditive"
-    )
-    omp_tag: Optional[Global[int]] = Field(default=None, validation_alias="ompTag", serialization_alias="ompTag")
-    preference: Optional[Global[int]] = Field(default=None)
-    service: Optional[Service] = Field(default=None)
-    service_chain: Optional[ServiceChain] = Field(
-        default=None, validation_alias="serviceChain", serialization_alias="serviceChain"
-    )
-    tloc: Optional[Tloc] = Field(default=None)
-    tloc_action: Optional[Global[TLOCActionType]] = Field(
-        default=None, validation_alias="tlocAction", serialization_alias="tlocAction"
-    )
-    tloc_list: Optional[RefIdItem] = Field(default=None, validation_alias="tlocList", serialization_alias="tlocList")
-
-
-class Actions(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    export_to: Optional[Global[List[str]]] = Field(
-        default=None, validation_alias="exportTo", serialization_alias="exportTo"
-    )
-    set: Optional[List[ActionSet]] = Field(default=None)
-
-
-class Sequence(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    actions: Optional[List[Actions]] = Field(default=None)
-    base_action: Optional[Global[AcceptRejectActionType]] = Field(
-        default=None, validation_alias="baseAction", serialization_alias="baseAction"
-    )
-    match: Optional[Match] = Field(default=None)
-    sequence_id: Optional[Global[int]] = Field(
-        default=None, validation_alias="sequenceId", serialization_alias="sequenceId"
-    )
-    sequence_ip_type: Optional[Global[SequenceIpType]] = Field(
-        default=None, validation_alias="sequenceIpType", serialization_alias="sequenceIpType"
-    )
-    sequence_name: Optional[Global[str]] = Field(
-        default=None, validation_alias="sequenceName", serialization_alias="sequenceName"
-    )
-    sequence_type: Optional[Global[ControlSequenceType]] = Field(
-        default=None, validation_alias="sequenceType", serialization_alias="sequenceType"
-    )
-
-    def _get_match(self) -> Match:
-        if self.match is None:
-            self.match = Match(entries=[])
-        if self.match.entries is None:
-            self.match.entries = []
-        return self.match
-
-    def _match(self, entry: Entry):
-        self._get_match().entries.append(entry)
-
-    def _get_regions_entry(self) -> Entry:
-        entries = self._get_match().entries
-        for entry in entries:
-            if entry.regions is not None:
-                return entry
-        entry = Entry()
-        entries.append(entry)
-        return entry
-
-    @property
-    def _action(self) -> Actions:
-        if not self.actions:
-            self.actions = [Actions()]
-        return self.actions[0]
-
-    @property
-    def _action_set(self) -> ActionSet:
-        action = self._action
-        if action.set is None:
-            action.set = [ActionSet()]
-        return action.set[0]
-
-    def match_carrier(self, carrier: CarrierType):
-        entry = Entry(carrier=as_global(carrier, CarrierType))
-        self._match(entry)
-
-    def match_color_list(self, list_id: UUID):
-        entry = Entry(color_list=RefIdItem(ref_id=as_global(str(list_id))))
-        self._match(entry)
-
-    def match_community(self, list_id: UUID):
-        entry = Entry(community=RefIdItem(ref_id=as_global(str(list_id))))
-        self._match(entry)
-
-    def match_domain_id(self, domain_id: int):
-        entry = Entry(domain_id=as_global(domain_id))
-        self._match(entry)
-
-    def match_expanded_community(self, list_id: UUID):
-        entry = Entry(expanded_community=RefIdItem(ref_id=as_global(str(list_id))))
-        self._match(entry)
-
-    def match_group_id(self, group_id: int):
-        entry = Entry(group_id=as_global(group_id))
-        self._match(entry)
-
-    def match_ipv6prefix_list(self, list_id: UUID):
-        entry = Entry(ipv6prefix_list=RefIdItem(ref_id=as_global(str(list_id))))
-        self._match(entry)
-
-    def match_omp_tag(self, omp_tag: int):
-        entry = Entry(omp_tag=as_global(omp_tag))
-        self._match(entry)
-
-    def match_origin(self, origin: OriginProtocol):
-        entry = Entry(origin=as_global(origin, OriginProtocol))
-        self._match(entry)
-
-    def match_originator(self, originator: IPv4Address):
-        entry = Entry(originator=as_global(str(originator)))
-        self._match(entry)
-
-    def match_path_type(self, path_type: ControlPathType):
-        entry = Entry(path_type=as_global(path_type, ControlPathType))
-        self._match(entry)
-
-    def match_preference(self, preference: int):
-        entry = Entry(preference=as_global(preference))
-        self._match(entry)
-
-    def match_prefix_list(self, list_id: UUID):
-        entry = Entry(prefix_list=RefIdItem(ref_id=as_global(str(list_id))))
-        self._match(entry)
-
-    def match_region(self, region: str, subregions: Optional[List[str]] = None):
-        _region = Region(
-            region=as_global(region),
-            sub_region=as_global(subregions) if subregions else None,
-        )
-        entry = self._get_regions_entry()
-        if entry.regions:
-            entry.regions.append(_region)
-        else:
-            entry.regions = [_region]
-
-    def match_role(self, role: MultiRegionRole):
-        entry = Entry(role=as_global(role, MultiRegionRole))
-        self._match(entry)
-
-    def match_sites(self, sites: List[str]):
-        entry = Entry(site=as_global(sites))
-        self._match(entry)
-
-    def match_tloc(self, ip: IPv4Address, color: TLOCColor, encap: EncapType):
-        entry = Entry(
-            tloc=Tloc(color=as_global(color, TLOCColor), encap=as_global(encap, EncapType), ip=as_global(str(ip)))
-        )
-        self._match(entry)
-
-    def match_tloc_list(self, list_id: UUID):
-        entry = Entry(tloc_list=RefIdItem(ref_id=as_global(str(list_id))))
-        self._match(entry)
-
-    def match_vpns(self, vpns: List[str]):
-        entry = Entry(vpn=as_global(vpns))
-        self._match(entry)
-
-    def associate_affinitty_action(self, affinity: int) -> None:
-        self._action_set.affinity = as_global(affinity)
-
-    def associate_community_additive_action(self, additive: bool) -> None:
-        self._action_set.community_additive = as_global(additive)
-
-    def associate_community_action(self, community: str) -> None:
-        self._action_set.community = as_global(community)
-
-    def associate_omp_tag_action(self, omp_tag: int) -> None:
-        self._action_set.omp_tag = as_global(omp_tag)
-
-    def associate_preference_action(self, preference: int) -> None:
-        self._action_set.preference = as_global(preference)
-
-    @overload
-    def associate_service_action(self, service_type: ServiceType, vpn: Optional[int], *, tloc_list_id: UUID) -> None:
-        ...
-
-    @overload
-    def associate_service_action(
-        self, service_type: ServiceType, vpn: Optional[int], *, ip: IPv4Address, color: TLOCColor, encap: EncapType
-    ) -> None:
-        ...
-
-    def associate_service_action(
-        self, service_type=ServiceType, vpn=Optional[int], *, tloc_list_id=None, ip=None, color=None, encap=None
-    ) -> None:
-        _vpn = as_global(vpn) if vpn is not None else None
-        _service_type = as_global(service_type, ServiceType)
-        if tloc_list_id is not None:
-            service = Service(
-                tloc_list=RefIdItem(ref_id=as_global(str(tloc_list_id))),
-                type=_service_type,
-                vpn=_vpn,
-            )
-        else:
-            _tloc = Tloc.from_params(color=color, encap=encap, ip=ip)
-            service = Service(tloc=_tloc, type=_service_type, vpn=_vpn)
-        self._action_set.service = service
-
-    def associate_tloc(self, color: TLOCColor, encap: EncapType, ip: IPv4Address) -> None:
-        self._action_set.tloc = Tloc.from_params(color=color, encap=encap, ip=ip)
-
-    def associate_tloc_action(self, tloc_action_type: TLOCActionType) -> None:
-        self._action_set.tloc_action = as_global(tloc_action_type, TLOCActionType)
-
-    def associate_tloc_list(self, tloc_list_id: UUID) -> None:
-        self._action_set.tloc_list = RefIdItem(ref_id=as_global(str(tloc_list_id)))
-
-
-class CustomControlParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["custom-control"] = Field(default="custom-control", exclude=True)
-    default_action: Optional[Global[AcceptRejectActionType]] = Field(
-        default=None, validation_alias=AliasPath("data", "defaultAction")
-    )
-    sequences: Optional[List[Sequence]] = Field(
-        default=None,
-        validation_alias=AliasPath("data", "sequences"),
-        description="Sequence list",
-    )
-    target: Optional[Target] = Field(
-        default=None,
-        validation_alias=AliasPath("data", "target"),
-        description="Target",
-    )
-
-    def set_default_action(self, action: AcceptRejectActionType = "reject"):
-        self.default_action = as_global(action, AcceptRejectActionType)
-
-    def assign_target_sites(
-        self,
-        inbound_sites: List[str],
-        outbound_sites: List[str],
-        _dummy_vpns: Optional[
-            List[str]
-        ],  # mitigate a bug (vpn is not used but value needs to be provided for server to accept the message)
-    ) -> Target:
-        self.target = Target(
-            vpn=Global[List[str]](value=_dummy_vpns) if _dummy_vpns is not None else None,
-            level=as_global("SITE", Level),
-            inbound_sites=as_global(inbound_sites),
-            outbound_sites=as_global(outbound_sites),
-        )
-        return self.target
-
-    def add_sequence(
-        self,
-        name: str,
-        id_: int,
-        type_: ControlSequenceType,
-        ip_type: SequenceIpType,
-        base_action: AcceptRejectActionType,
-    ) -> Sequence:
-        seq = Sequence(
-            base_action=as_global(base_action, AcceptRejectActionType),
-            sequence_id=as_global(id_),
-            sequence_ip_type=as_global(ip_type, SequenceIpType),
-            sequence_name=as_global(name),
-            sequence_type=as_global(type_, ControlSequenceType),
-        )
-        if self.sequences is None:
-            self.sequences = [seq]
-        else:
-            self.sequences.append(seq)
-        return seq

catalystwan/models/configuration/feature_profile/sdwan/topology/hubspoke.py

@@ -1,60 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
-
-
-class Target(BaseModel):
-    vpn: Global[List[str]] = as_global([])
-
-
-class HubSite(BaseModel):
-    sites: Global[List[str]]
-    preference: Global[int]
-
-
-class Spoke(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    name: Global[str]
-    spoke_sites: Global[List[str]] = Field(
-        default=as_global([]), validation_alias="spokeSites", serialization_alias="spokeSites"
-    )
-    hub_sites: Optional[List[HubSite]] = Field(
-        default=None, validation_alias="hubSites", serialization_alias="hubSites"
-    )
-
-    @staticmethod
-    def create(name: str, spoke_sites: List[str]) -> "Spoke":
-        return Spoke(name=as_global(name), spoke_sites=Global[List[str]](value=spoke_sites))
-
-    def add_hub_site(self, sites: List[str], preference: int) -> HubSite:
-        hub_site = HubSite(sites=Global[List[str]](value=sites), preference=as_global(preference))
-        if self.hub_sites is None:
-            self.hub_sites = [hub_site]
-        else:
-            self.hub_sites.append(hub_site)
-        return hub_site
-
-    def add_spoke_site(self, site: str):
-        self.spoke_sites.value.append(site)
-
-
-class HubSpokeParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["hubspoke"] = Field(default="hubspoke", exclude=True)
-    target: Target = Field(default=Target(), validation_alias=AliasPath("data", "target"))
-    selected_hubs: Global[List[str]] = Field(default=as_global([]), validation_alias=AliasPath("data", "selectedHubs"))
-    spokes: List[Spoke] = Field(default_factory=list, validation_alias=AliasPath("data", "spokes"))
-
-    def add_spoke(self, name: str, spoke_sites: List[str]) -> Spoke:
-        spoke = Spoke.create(name=name, spoke_sites=spoke_sites)
-        self.spokes.append(spoke)
-        return spoke
-
-    def add_target_vpn(self, vpn: str) -> None:
-        self.target.vpn.value.append(vpn)
-
-    def add_selected_hub(self, hub: str) -> None:
-        self.selected_hubs.value.append(hub)

catalystwan/models/configuration/feature_profile/sdwan/topology/mesh.py

@@ -1,23 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from typing import List, Literal
-
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
-
-
-class Target(BaseModel):
-    vpn: Global[List[str]] = as_global([])
-
-
-class MeshParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["mesh"] = Field(default="mesh", exclude=True)
-    target: Target = Field(default=Target(), validation_alias=AliasPath("data", "target"), description="Target Vpn")
-    sites: Global[List[str]] = Field(default=as_global([]), validation_alias=AliasPath("data", "sites"))
-
-    def add_target_vpn(self, vpn: str) -> None:
-        self.target.vpn.value.append(vpn)
-
-    def add_site(self, site: str) -> None:
-        self.sites.value.append(site)

catalystwan/models/configuration/feature_profile/sdwan/trackers/__init__.py

@@ -1,36 +0,0 @@
-# Copyright 2025 Cisco Systems, Inc. and its affiliates
-from typing import List, Union
-
-from pydantic import Field
-from typing_extensions import Annotated
-
-from catalystwan.models.configuration.feature_profile.sdwan.trackers.tracker import (
-    EndpointTcpUdp,
-    EndpointTrackerType,
-    Tracker,
-    TrackerIPv6,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.trackers.tracker_group import (
-    TrackerGroup,
-    TrackerGroupIPv6,
-    TrackerRefs,
-)
-
-AnyTrackerParcel = Annotated[
-    Union[Tracker, TrackerIPv6, TrackerGroup, TrackerGroupIPv6],
-    Field(discriminator="type_"),
-]
-__all__ = [
-    "Tracker",
-    "TrackerIPv6",
-    "EndpointTcpUdp",
-    "EndpointTrackerType",
-    "TrackerGroup",
-    "TrackerGroupIPv6",
-    "TrackerRefs",
-    "AnyTrackerParcel",
-]
-
-
-def __dir__() -> "List[str]":
-    return list(__all__)

catalystwan/models/configuration/feature_profile/sdwan/trackers/tracker.py

@@ -1,96 +0,0 @@
-# Copyright 2025 Cisco Systems, Inc. and its affiliates
-from typing import Literal, Optional, Union
-
-from pydantic import AliasPath, BaseModel, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase
-
-Protocol = Literal[
-    "tcp",
-    "udp",
-]
-
-
-class EndpointTcpUdp(BaseModel):
-    port: Optional[Union[Variable, Global[int]]] = Field(default=None)
-    protocol: Optional[Union[Variable, Global[Protocol]]] = Field(default=None)
-
-
-EndpointTrackerType = Literal[
-    "ipv6-interface",
-    "ipv6-interface-icmp",
-]
-
-
-class Tracker(_ParcelBase):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    type_: Literal["tracker"] = Field(default="tracker", exclude=True, frozen=True)
-    tracker_name: Union[Variable, Global[str]] = Field(validation_alias=AliasPath("data", "trackerName"))
-    tracker_type: Union[Default[Literal["endpoint"]], Variable, Global[Literal["endpoint"]]] = Field(
-        default=Default[Literal["endpoint"]](value="endpoint"), validation_alias=AliasPath("data", "trackerType")
-    )
-    endpoint_api_url: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointApiUrl")
-    )
-    endpoint_dns_name: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointDnsName")
-    )
-    endpoint_ip: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointIp")
-    )
-    endpoint_tcp_udp: Optional[EndpointTcpUdp] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointTcpUdp"), description="Endpoint tcp/udp"
-    )
-    endpoint_tracker_type: Optional[
-        Union[Variable, Default[Literal["static-route"]], Global[Literal["static-route"]]]
-    ] = Field(default=None, validation_alias=AliasPath("data", "endpointTrackerType"))
-    interval: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "interval")
-    )
-    multiplier: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "multiplier")
-    )
-    threshold: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "threshold")
-    )
-
-
-class TrackerIPv6(_ParcelBase):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    type_: Literal["ipv6-tracker"] = Field(default="ipv6-tracker", exclude=True, frozen=True)
-    endpoint_api_url: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointApiUrl")
-    )
-    endpoint_dns_name: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointDnsName")
-    )
-    endpoint_ip: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointIp")
-    )
-    endpoint_tracker_type: Optional[Union[Default[Literal["ipv6-interface"]], Global[EndpointTrackerType]]] = Field(
-        default=None, validation_alias=AliasPath("data", "endpointTrackerType")
-    )
-    icmp_interval: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "icmpInterval")
-    )
-    interval: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "interval")
-    )
-    multiplier: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "multiplier")
-    )
-    threshold: Optional[Union[Default[int], Variable, Global[int]]] = Field(
-        default=None, validation_alias=AliasPath("data", "threshold")
-    )
-    tracker_name: Optional[Union[Variable, Global[str]]] = Field(
-        default=None, validation_alias=AliasPath("data", "trackerName")
-    )
-    tracker_type: Optional[Union[Default[Literal["endpoint"]], Variable, Global[Literal["endpoint"]]]] = Field(
-        default=None, validation_alias=AliasPath("data", "trackerType")
-    )