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

catalystwan/models/configuration/feature_profile/sdwan/acl/ipv6acl.py

@@ -0,0 +1,344 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from ipaddress import IPv6Address, IPv6Interface
+from typing import List, Literal, Optional, Tuple, Union
+from uuid import UUID
+
+from pydantic import AliasPath, BaseModel, ConfigDict, Field, model_validator
+
+from catalystwan.api.configuration_groups.parcel import Default, Global, _ParcelBase, as_global
+from catalystwan.models.common import AcceptDropActionType, check_fields_exclusive
+from catalystwan.models.configuration.feature_profile.common import RefIdItem
+
+
+class SourceDataPrefixList(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    source_data_prefix_list: Optional[RefIdItem] = Field(
+        default=None, validation_alias="sourceDataPrefixList", serialization_alias="sourceDataPrefixList"
+    )
+
+
+class SourceDataPrefix(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    source_ip_prefix: Optional[Global[str]] = Field(
+        default=None, validation_alias="sourceIpPrefix", serialization_alias="sourceIpPrefix"
+    )
+
+
+class SourcePorts(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    source_port: Union[Global[str], Global[int], None] = Field(
+        default=None, validation_alias="sourcePort", serialization_alias="sourcePort"
+    )
+
+
+class DestinationDataPrefixList(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_data_prefix_list: Optional[RefIdItem] = Field(
+        default=None, validation_alias="destinationDataPrefixList", serialization_alias="destinationDataPrefixList"
+    )
+
+
+class DestinationDataPrefix(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_ip_prefix: Optional[Global[str]] = Field(
+        default=None, validation_alias="destinationIpPrefix", serialization_alias="destinationIpPrefix"
+    )
+
+
+class DestinationPorts(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_port: Union[Global[str], Global[int], None] = Field(
+        default=None, validation_alias="destinationPort", serialization_alias="destinationPort"
+    )
+
+
+IcmpIPv6Messages = Literal[
+    "beyond-scope",
+    "cp-advertisement",
+    "cp-solicitation",
+    "destination-unreachable",
+    "dhaad-reply",
+    "dhaad-request",
+    "echo-reply",
+    "echo-request",
+    "header",
+    "hop-limit",
+    "ind-advertisement",
+    "ind-solicitation",
+    "mld-query",
+    "mld-reduction",
+    "mld-report",
+    "mldv2-report",
+    "mpd-advertisement",
+    "mpd-solicitation",
+    "mr-advertisement",
+    "mr-solicitation",
+    "mr-termination",
+    "nd-na",
+    "nd-ns",
+    "next-header-type",
+    "ni-query",
+    "ni-query-name",
+    "ni-query-v4-address",
+    "ni-query-v6-address",
+    "ni-response",
+    "ni-response-qtype-unknown",
+    "ni-response-refuse",
+    "ni-response-success",
+    "no-admin",
+    "no-route",
+    "packet-too-big",
+    "parameter-option",
+    "parameter-problem",
+    "port-unreachable",
+    "reassembly-timeout",
+    "redirect",
+    "reject-route",
+    "renum-command",
+    "renum-result",
+    "renum-seq-number",
+    "router-advertisement",
+    "router-renumbering",
+    "router-solicitation",
+    "rpl-control",
+    "source-policy",
+    "source-route-header",
+    "time-exceeded",
+    "unreachable",
+]
+
+
+class MatchEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_data_prefix: Union[DestinationDataPrefix, DestinationDataPrefixList, None] = Field(
+        default=None, validation_alias="destinationDataPrefix", serialization_alias="destinationDataPrefix"
+    )
+    destination_ports: Optional[List[DestinationPorts]] = Field(
+        default=None,
+        validation_alias="destinationPorts",
+        serialization_alias="destinationPorts",
+        description="Destination Port List",
+    )
+    icmp6_msg: Optional[Global[List[IcmpIPv6Messages]]] = Field(
+        default=None, validation_alias="icmp6Msg", serialization_alias="icmp6Msg"
+    )
+    next_header: Optional[Global[int]] = Field(
+        default=None, validation_alias="nextHeader", serialization_alias="nextHeader"
+    )
+    packet_length: Optional[Global[Union[str, int]]] = Field(
+        default=None, validation_alias="packetLength", serialization_alias="packetLength"
+    )
+    source_data_prefix: Union[SourceDataPrefix, SourceDataPrefixList, None] = Field(
+        default=None, validation_alias="sourceDataPrefix", serialization_alias="sourceDataPrefix"
+    )
+    source_ports: Optional[List[SourcePorts]] = Field(
+        default=None, validation_alias="sourcePorts", serialization_alias="sourcePorts", description="Source Port List"
+    )
+    tcp: Optional[Global[Literal["syn"]]] = Field(default=None)
+    traffic_class: Optional[Global[List[int]]] = Field(
+        default=None, validation_alias="trafficClass", serialization_alias="trafficClass"
+    )
+
+
+class Accept(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    counter_name: Optional[Global[str]] = Field(
+        default=None, validation_alias="counterName", serialization_alias="counterName"
+    )
+    log: Optional[Union[Global[bool], Default[bool]]] = Field(default=None)
+    mirror: Optional[RefIdItem] = Field(default=None)
+    policer: Optional[RefIdItem] = Field(default=None)
+    set_next_hop: Optional[Global[str]] = Field(
+        default=None, validation_alias="setNextHop", serialization_alias="setNextHop"
+    )
+    set_traffic_class: Optional[Global[int]] = Field(
+        default=None, validation_alias="setTrafficClass", serialization_alias="setTrafficClass"
+    )
+
+
+class AcceptAction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    accept: Accept = Field(description="Accept Action")
+
+
+class Drop(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    counter_name: Optional[Global[str]] = Field(
+        default=None, validation_alias="counterName", serialization_alias="counterName"
+    )
+    log: Optional[Union[Global[bool], Default[bool]]] = Field(default=None)
+
+
+class DropAction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    drop: Drop = Field(description="Drop Action")
+
+
+class Sequence(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    actions: Optional[List[Union[AcceptAction, DropAction]]] = Field(default=None, description="Define list of actions")
+    base_action: Optional[Union[Global[AcceptDropActionType], Default[Literal["accept"]]]] = Field(
+        default=None, validation_alias="baseAction", serialization_alias="baseAction"
+    )
+    match_entries: Optional[List[MatchEntry]] = Field(
+        default=None,
+        validation_alias="matchEntries",
+        serialization_alias="matchEntries",
+        description="Define match conditions",
+    )
+    sequence_id: Optional[Global[int]] = Field(
+        default=None, validation_alias="sequenceId", serialization_alias="sequenceId"
+    )
+    sequence_name: Optional[Global[str]] = Field(
+        default=None, validation_alias="sequenceName", serialization_alias="sequenceName"
+    )
+
+    @model_validator(mode="after")
+    def check_base_action_xor_actions(self):
+        check_fields_exclusive(self.__dict__, {"base_action", "actions"}, True)
+        return self
+
+    def _action(self, mode: Optional[AcceptDropActionType] = None) -> Union[AcceptAction, DropAction]:
+        if mode is None and self.base_action is not None:
+            _mode = self.base_action.value
+        else:
+            _mode = mode
+        self.base_action = None
+        if self.actions is None:
+            if _mode == "drop":
+                self.actions = [(DropAction(drop=Drop()))]
+            else:
+                self.actions = [(AcceptAction(accept=Accept()))]
+        return self.actions[0]
+
+    @property
+    def _accept_action(self) -> Accept:
+        action = self._action("accept")
+        assert isinstance(action, AcceptAction), "Sequence action must be set to accept"
+        return action.accept
+
+    @property
+    def _drop_action(self) -> Drop:
+        action = self._action("drop")
+        assert isinstance(action, DropAction), "Sequence action must be set to drop"
+        return action.drop
+
+    @property
+    def _entry(self) -> MatchEntry:
+        if self.match_entries is None:
+            self.match_entries = [MatchEntry()]
+        return self.match_entries[0]
+
+    def match_destination_data_prefix(self, prefix: IPv6Interface):
+        value = as_global(str(prefix))
+        self._entry.destination_data_prefix = DestinationDataPrefix(destination_ip_prefix=value)
+
+    def match_destination_data_prefix_list(self, list_id: UUID):
+        value = as_global(str(list_id))
+        self._entry.destination_data_prefix = DestinationDataPrefixList(
+            destination_data_prefix_list=RefIdItem(ref_id=value)
+        )
+
+    def match_destination_ports(self, ports: List[Union[int, Tuple[int, int]]]):
+        """
+        ports argument example: [1, 3, (10,100), (50,200), 600]
+        """
+        destination_ports = []
+        for port in ports:
+            if isinstance(port, int):
+                value = as_global(port)
+            else:
+                value = as_global(f"{port[0]}-{port[1]}")
+            destination_ports.append(DestinationPorts(destination_port=value))
+        self._entry.destination_ports = destination_ports
+
+    def match_icmp_msg(self, icmp: List[IcmpIPv6Messages]):
+        self._entry.icmp6_msg = Global[List[IcmpIPv6Messages]](value=icmp)
+
+    def match_packet_length(self, len: Union[int, Tuple[int, int]]):
+        if isinstance(len, int):
+            value = as_global(len)
+        else:
+            value = as_global(f"{len[0]}-{len[1]}")
+        self._entry.packet_length = value
+
+    def match_source_data_prefix(self, prefix: IPv6Interface):
+        value = as_global(str(prefix))
+        self._entry.source_data_prefix = SourceDataPrefix(source_ip_prefix=value)
+
+    def match_source_data_prefix_list(self, list_id: UUID):
+        value = as_global(str(list_id))
+        self._entry.source_data_prefix = SourceDataPrefixList(source_data_prefix_list=RefIdItem(ref_id=value))
+
+    def match_source_ports(self, ports: List[Union[int, Tuple[int, int]]]):
+        """
+        ports argument example: [1, 3, (10,100), (50,200), 600]
+        """
+        source_ports = []
+        for port in ports:
+            if isinstance(port, int):
+                value = as_global(port)
+            else:
+                value = as_global(f"{port[0]}-{port[1]}")
+            source_ports.append(SourcePorts(source_port=value))
+        self._entry.source_ports = source_ports
+
+    def match_tcp(self):
+        self._entry.tcp = as_global("syn", Literal["syn"])
+
+    def match_traffic_class(self, classes: List[int]):
+        self._entry.traffic_class = as_global(classes)
+
+    def associate_log_action(self):
+        if isinstance(self._action(), DropAction):
+            self._drop_action.log = as_global(True)
+        else:
+            self._accept_action.log = as_global(True)
+
+    def associate_counter_action(self, name: str):
+        if isinstance(self._action(), DropAction):
+            self._drop_action.counter_name = as_global(name)
+        else:
+            self._accept_action.counter_name = as_global(name)
+
+    def associate_mirror_action(self, mirror: UUID):
+        self._accept_action.mirror = RefIdItem(ref_id=as_global(str(mirror)))
+
+    def associate_policer_action(self, policer: UUID):
+        self._accept_action.policer = RefIdItem(ref_id=as_global(str(policer)))
+
+    def associate_set_traffic_class_action(self, traffic_class: int):
+        self._accept_action.set_traffic_class = as_global(traffic_class)
+
+    def associate_set_next_hop_action(self, next_hop: IPv6Address):
+        self._accept_action.set_next_hop = as_global(str(next_hop))
+
+
+class Ipv6AclParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type_: Literal["ipv6-acl"] = Field(default="ipv6-acl", exclude=True)
+    default_action: Union[Global[AcceptDropActionType], Default[Literal["drop"]]] = Field(
+        default=Default[Literal["drop"]](value="drop"), validation_alias=AliasPath("data", "defaultAction")
+    )
+    sequences: List[Sequence] = Field(
+        default_factory=list, validation_alias=AliasPath("data", "sequences"), description="Access Control List"
+    )
+
+    def set_default_action(self, action: AcceptDropActionType):
+        self.default_action = as_global(action, AcceptDropActionType)
+
+    def add_sequence(self, name: str, id_: int, base_action: Optional[AcceptDropActionType] = None) -> Sequence:
+        if base_action is not None:
+            _base_action = as_global(base_action, AcceptDropActionType)
+        else:
+            _base_action = Default[Literal["accept"]](value="accept")
+        seq = Sequence(
+            base_action=_base_action,
+            sequence_id=as_global(id_),
+            sequence_name=as_global(name),
+        )
+        if self.sequences is None:
+            self.sequences = [seq]
+        else:
+            self.sequences.append(seq)
+        return seq

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

@@ -0,0 +1,218 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+
+from typing import List, Union
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from .cloud_probe import CloudProbeParcel
+from .policy_settings import Cflowd, PolicySettingsParcel
+from .qos_policy import QosMap, QosPolicyParcel, QosPolicyTarget, QosSchedulers
+from .traffic_policy import (
+    Action,
+    AppListMatch,
+    AppqoeOptimization,
+    AppqoeOptimizationAction,
+    BackupSlaPreferredColorAction,
+    CflowdAction,
+    CloudProbeAction,
+    CloudSaasAction,
+    CountAction,
+    DestinationDataIpv6PrefixListMatch,
+    DestinationDataPrefixListMatch,
+    DestinationIpMatch,
+    DestinationIpv6Match,
+    DestinationPortMatch,
+    DestinationRegion,
+    DestinationRegionMatch,
+    DnsAppListMatch,
+    DNSEntryType,
+    DnsMatch,
+    DNSTypeEntryType,
+    DscpMatch,
+    EncapType,
+    Entry,
+    FallbackToRoutingAction,
+    Icmp6MessageMatch,
+    IcmpMessageMatch,
+    LocalTlocList,
+    LogAction,
+    LossCorrection,
+    LossCorrectionAction,
+    LossProtectionType,
+    Match,
+    Nat,
+    NatAction,
+    NatPoolAction,
+    PacketLengthMatch,
+    PreferredRemoteColor,
+    ProtocolMatch,
+    RedirectDns,
+    RedirectDnsAction,
+    SaasAppListMatch,
+    SecureServiceEdgeInstance,
+    Sequence,
+    SequenceIpType,
+    ServiceAreaMatch,
+    ServiceAreaValue,
+    ServiceChain,
+    ServiceChainNumber,
+    ServiceTloc,
+    ServiceTlocList,
+    ServiceType,
+    Set,
+    SetAction,
+    SetDscp,
+    SetForwardingClass,
+    SetLocalTlocList,
+    SetNextHop,
+    SetNextHopIpv6,
+    SetNextHopLoose,
+    SetPolicer,
+    SetPreferredColorGroup,
+    SetPreferredRemoteColor,
+    SetService,
+    SetServiceChain,
+    SetTloc,
+    SetTlocList,
+    SetVpn,
+    SigAction,
+    SlaClass,
+    SlaClassAction,
+    SourceDataIpv6PrefixListMatch,
+    SourceDataPrefixListMatch,
+    SourceIpMatch,
+    SourceIpv6Match,
+    SourcePortMatch,
+    Sse,
+    SseAction,
+    TcpMatch,
+    Tloc,
+    TLOCColor,
+    TrafficCategory,
+    TrafficCategoryMatch,
+    TrafficClass,
+    TrafficClassMatch,
+    TrafficPolicyParcel,
+    TrafficPolicyTarget,
+    TrafficTargetType,
+    TrafficToMatch,
+)
+
+AnyApplicationPriorityParcel = Annotated[
+    Union[
+        CloudProbeParcel,
+        PolicySettingsParcel,
+        QosPolicyParcel,
+        TrafficPolicyParcel,
+    ],
+    Field(discriminator="type_"),
+]
+
+__all__ = (
+    "Action",
+    "AnyApplicationPriorityParcel",
+    "AppListMatch",
+    "AppqoeOptimization",
+    "AppqoeOptimizationAction",
+    "BackupSlaPreferredColorAction",
+    "Cflowd",
+    "CflowdAction",
+    "CloudProbeAction",
+    "CloudProbeParcel",
+    "CloudSaasAction",
+    "CountAction",
+    "DestinationDataIpv6PrefixListMatch",
+    "DestinationDataPrefixListMatch",
+    "DestinationIpMatch",
+    "DestinationIpv6Match",
+    "DestinationPortMatch",
+    "DestinationRegion",
+    "DestinationRegionMatch",
+    "DnsAppListMatch",
+    "DNSEntryType",
+    "DnsMatch",
+    "DNSTypeEntryType",
+    "DscpMatch",
+    "EncapType",
+    "Entry",
+    "FallbackToRoutingAction",
+    "Icmp6MessageMatch",
+    "Icmp6MessageValue",
+    "IcmpMessageMatch",
+    "IcmpMsg",
+    "LocalTlocList",
+    "LogAction",
+    "LossCorrection",
+    "LossCorrectionAction",
+    "LossProtectionType",
+    "Match",
+    "Nat",
+    "NatAction",
+    "NatPoolAction",
+    "PacketLengthMatch",
+    "PolicySettingsParcel",
+    "PreferredRemoteColor",
+    "ProtocolMatch",
+    "QosMap",
+    "QosPolicyParcel",
+    "QosPolicyTarget",
+    "QosSchedulers",
+    "RedirectDns",
+    "RedirectDnsAction",
+    "RedirectDnsValue",
+    "SaasAppListMatch",
+    "SecureServiceEdgeInstance",
+    "Sequence",
+    "SequenceIpType",
+    "ServiceAreaMatch",
+    "ServiceAreaValue",
+    "ServiceChain",
+    "ServiceChainNumber",
+    "ServiceTloc",
+    "ServiceTlocList",
+    "ServiceType",
+    "Set",
+    "SetAction",
+    "SetDscp",
+    "SetForwardingClass",
+    "SetLocalTlocList",
+    "SetNextHop",
+    "SetNextHopIpv6",
+    "SetNextHopLoose",
+    "SetPolicer",
+    "SetPreferredColorGroup",
+    "SetPreferredRemoteColor",
+    "SetService",
+    "SetServiceChain",
+    "SetTloc",
+    "SetTlocList",
+    "SetVpn",
+    "SigAction",
+    "SlaClass",
+    "SlaClassAction",
+    "SourceDataIpv6PrefixListMatch",
+    "SourceDataPrefixListMatch",
+    "SourceIpMatch",
+    "SourceIpv6Match",
+    "SourcePortMatch",
+    "Sse",
+    "SseAction",
+    "TcpMatch",
+    "Tloc",
+    "TLOCColor",
+    "TrafficCategory",
+    "TrafficCategoryMatch",
+    "TrafficClass",
+    "TrafficClassMatch",
+    "TrafficPolicyParcel",
+    "TrafficPolicyTarget",
+    "TrafficPolicyTarget",
+    "TrafficTargetType",
+    "TrafficToMatch",
+)
+
+
+def __dir__() -> "List[str]":
+    return list(__all__)

catalystwan/models/configuration/feature_profile/sdwan/application_priority/cloud_probe.py

@@ -0,0 +1,61 @@
+# Copyright 2025 Cisco Systems, Inc. and its affiliates
+from typing import List, Literal, Optional, Union
+
+from pydantic import AliasPath, BaseModel, Field
+
+from catalystwan.api.configuration_groups.parcel import Global, Variable, _ParcelBase
+from catalystwan.models.common import TLOCColor
+
+CloudSaaSDeviceRole = Literal[
+    "client",
+    "dia",
+    "gateway",
+]
+
+VpnType = Literal[
+    "service-vpn",
+    "vpn-0",
+]
+
+
+class Loadbalance(BaseModel):
+    latency: Optional[Union[Global[str], Variable]] = Field(default=None)
+    loss: Optional[Union[Global[str], Variable]] = Field(default=None)
+    source_ip_based: Optional[Union[Global[bool], Variable]] = Field(
+        default=None, validation_alias="sourceIpBased", serialization_alias="sourceIpBased"
+    )
+
+
+class CloudProbeParcel(_ParcelBase):
+    type_: Literal["could-probe"] = Field(default="could-probe", exclude=True)
+    cloud_saa_s_device_role: Optional[Union[Variable, Global[CloudSaaSDeviceRole]]] = Field(
+        default=None,
+        validation_alias=AliasPath("data", "cloudSaaSDeviceRole"),
+    )
+    cloud_saa_s_l_b_enabled: Optional[Union[Global[bool], Variable]] = Field(
+        default=None,
+        validation_alias=AliasPath("data", "cloudSaaSLBEnabled"),
+    )
+    cloud_saa_s_sig_enabled: Optional[Union[Global[bool], Variable]] = Field(
+        default=None,
+        validation_alias=AliasPath("data", "cloudSaaSSigEnabled"),
+    )
+    interface_list: Optional[Union[Global[List[str]], Variable]] = Field(
+        default=None,
+        validation_alias=AliasPath("data", "interfaceList"),
+    )
+    loadbalance: Optional[Loadbalance] = Field(
+        default=None,
+        validation_alias=AliasPath("data", "loadbalance"),
+    )
+    parcel_type: Optional[str] = Field(default=None, validation_alias="parcelType", serialization_alias="parcelType")
+    sig_tunnel_list: Optional[Union[Global[List[str]], Variable]] = Field(
+        default=None,
+        validation_alias=AliasPath("data", "sigTunnelList"),
+    )
+    tloc_list: Optional[Union[Global[List[TLOCColor]], Variable]] = Field(
+        default=None, validation_alias=AliasPath("data", "tlocList")
+    )
+    vpn_type: Optional[Union[Variable, Global[VpnType]]] = Field(
+        default=None, validation_alias=AliasPath("data", "vpnType")
+    )

catalystwan/models/configuration/feature_profile/sdwan/application_priority/policy_settings.py

@@ -0,0 +1,31 @@
+# Copyright 2024 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, _ParcelBase
+
+
+class Cflowd(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    value: bool
+    option_type: Literal["network-settings"] = Field(
+        default="network-settings", validation_alias="optionType", serialization_alias="optionType"
+    )
+
+
+class PolicySettingsParcel(_ParcelBase):
+    type_: Literal["policy-settings"] = Field(default="policy-settings", exclude=True)
+    app_visibility: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None, validation_alias=AliasPath("data", "appVisibility")
+    )
+    app_visibility_ipv6: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None, validation_alias=AliasPath("data", "appVisibilityIPv6")
+    )
+    cflowd: Optional[Cflowd] = Field(default=None, validation_alias=AliasPath("data", "cflowd"))
+    flow_visibility: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None, validation_alias=AliasPath("data", "flowVisibility")
+    )
+    flow_visibility_ipv6: Optional[Union[Global[bool], Default[bool]]] = Field(
+        default=None, validation_alias=AliasPath("data", "flowVisibilityIPv6")
+    )