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

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

@@ -1,127 +1,84 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from __future__ import annotations
+from typing import List, Optional, Union
 
-import re
-from ipaddress import IPv4Address
-from typing import List, Literal, Optional, Union
+from pydantic import BaseModel, ConfigDict, Field
 
-from pydantic import AliasPath, BaseModel, ConfigDict, Field, field_validator, model_validator
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable
 
-from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase
-from catalystwan.models.common import SubnetMask, check_fields_exclusive
 
-MAC_PATTERN_1 = re.compile(r"^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$")
-MAC_PATTERN_2 = re.compile(r"^[0-9a-fA-F]{4}\.[0-9a-fA-F]{4}\.[0-9a-fA-F]{4}$")
+class OptionCodeAscii(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
+    code: Union[Global[int], Variable]
+    ascii: Union[Global[str], Variable]
 
-class AddressPool(BaseModel):
-    """
-    Configure IPv4 prefix range of the DHCP address pool
-    """
 
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    network_address: Union[Variable, Global[IPv4Address]] = Field(
-        ..., serialization_alias="networkAddress", validation_alias="networkAddress", description="Network Address"
-    )
-    subnet_mask: Union[Variable, Global[SubnetMask]] = Field(
-        ..., serialization_alias="subnetMask", validation_alias="subnetMask", description="Subnet Mask"
-    )
+class OptionCodeHex(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
+    code: Union[Global[int], Variable]
+    hex: Union[Global[str], Variable]
 
-class StaticLeaseItem(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    mac_address: Union[Global[str], Variable] = Field(
-        ..., serialization_alias="macAddress", validation_alias="macAddress", description="Set MAC address of client"
-    )
-    ip: Union[Global[IPv4Address], Variable] = Field(..., description="Set client’s static IP address")
-
-    @field_validator("mac_address")
-    @classmethod
-    def check_mac_address(cls, mac_address: Union[Global[str], Variable]):
-        if mac_address.option_type == "variable":
-            return mac_address
-        value = mac_address.value
-        if MAC_PATTERN_1.match(value) or MAC_PATTERN_2.match(value):
-            return mac_address
-        raise ValueError("Invalid MAC address")
-
-
-class OptionCode(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    code: Union[Global[int], Variable] = Field(..., description="Set Option Code")
-    ip: Optional[Union[Global[List[IPv4Address]], Variable]] = Field(default=None, description="Set ip address")
-    hex: Optional[Union[Global[str], Variable]] = Field(default=None, description="Set HEX value")
-    ascii: Optional[Union[Global[str], Variable]] = Field(default=None, description="Set ASCII value")
-
-    @model_validator(mode="after")
-    def check_ip_hex_ascii_exclusive(self):
-        check_fields_exclusive(self.__dict__, {"ip", "hex", "ascii"}, True)
-        return self
-
-
-class LanVpnDhcpServerParcel(_ParcelBase):
-    """
-    LAN VPN DHCP Server profile parcel schema for POST request
-    """
-
-    type_: Literal["dhcp-server"] = Field(default="dhcp-server", exclude=True)
-    model_config = ConfigDict(
-        extra="forbid",
-        populate_by_name=True,
-    )
-    address_pool: AddressPool = Field(
-        ...,
-        validation_alias=AliasPath("data", "addressPool"),
-        description="Configure IPv4 prefix range of the DHCP address pool",
-    )
-    exclude: Union[Global[List[IPv4Address]], Global[List[str]], Variable, Default[None]] = Field(
-        default=Default[None](value=None),
-        validation_alias=AliasPath("data", "exclude"),
-        description="Configure IPv4 address to exclude from DHCP address pool",
+
+class OptionCodeIP(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    code: Union[Global[int], Variable]
+    ip: Union[Global[List[str]], Variable]
+
+
+class StaticLease(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    mac_address: Union[Global[str], Variable] = Field(serialization_alias="macAddress", validation_alias="macAddress")
+    ip: Union[Global[str], Variable]
+
+
+class DhcpAddressPool(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    network_address: Union[Global[str], Variable] = Field(
+        serialization_alias="networkAddress", validation_alias="networkAddress"
     )
-    lease_time: Union[Default[int], Global[int], Variable] = Field(
-        default=Default[int](value=86400),
-        validation_alias=AliasPath("data", "leaseTime"),
-        description="Configure how long a DHCP-assigned IP address is valid",
+    subnet_mask: Union[Global[str], Variable] = Field(serialization_alias="subnetMask", validation_alias="subnetMask")
+
+
+class DhcpServerData(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    address_pool: DhcpAddressPool = Field(serialization_alias="addressPool", validation_alias="addressPool")
+    exclude: Optional[Union[Global[List[str]], Variable, Default[None]]] = None
+    lease_time: Optional[Union[Global[int], Variable, Default[int]]] = Field(
+        serialization_alias="leaseTime", validation_alias="leaseTime", default=Default[int](value=86400)
     )
-    interface_mtu: Union[Global[int], Variable, Default[None]] = Field(
-        default=Default[None](value=None),
-        validation_alias=AliasPath("data", "interfaceMtu"),
-        description="Set MTU on interface to DHCP client",
+    interface_mtu: Optional[Union[Global[int], Variable, Default[None]]] = Field(
+        serialization_alias="interfaceMtu", validation_alias="interfaceMtu", default=None
     )
-    domain_name: Union[Global[str], Variable, Default[None]] = Field(
-        default=Default[None](value=None),
-        validation_alias=AliasPath("data", "domainName"),
-        description="Set domain name client uses to resolve hostnames",
+    domain_name: Optional[Union[Global[str], Variable, Default[None]]] = Field(
+        serialization_alias="domainName", validation_alias="domainName", default=None
     )
-    default_gateway: Union[Global[IPv4Address], Variable, Default[None]] = Field(
-        default=Default[None](value=None),
-        validation_alias=AliasPath("data", "defaultGateway"),
-        description="Set IP address of default gateway",
+    default_gateway: Optional[Union[Global[str], Variable, Default[None]]] = Field(
+        serialization_alias="defaultGateway", validation_alias="defaultGateway", default=None
     )
-    dns_servers: Union[Global[List[IPv4Address]], Variable, Default[None]] = Field(
-        default=Default[None](value=None),
-        validation_alias=AliasPath("data", "dnsServers"),
-        description="Configure one or more DNS server IP addresses",
+    dns_servers: Optional[Union[Global[List[str]], Variable, Default[None]]] = Field(
+        serialization_alias="dnsServers", validation_alias="dnsServers", default=None
     )
-    tftp_servers: Union[Global[List[IPv4Address]], Variable, Default[None]] = Field(
-        default=Default[None](value=None),
-        validation_alias=AliasPath("data", "tftpServers"),
-        description="Configure TFTP server IP addresses",
+    tftp_servers: Optional[Union[Global[List[str]], Variable, Default[None]]] = Field(
+        serialization_alias="tftpServers", validation_alias="tftpServers", default=None
     )
-    static_lease: Optional[List[StaticLeaseItem]] = Field(
-        default=None, validation_alias=AliasPath("data", "staticLease"), description="Configure static IP addresses"
+    static_lease: Optional[List[StaticLease]] = Field(
+        serialization_alias="staticLease", validation_alias="staticLease", default=None
     )
-    option_code: Optional[List[OptionCode]] = Field(
-        default=None, validation_alias=AliasPath("data", "optionCode"), description="Configure Options Code"
+    option_code: Optional[List[Union[OptionCodeAscii, OptionCodeHex, OptionCodeIP]]] = Field(
+        serialization_alias="optionCode", validation_alias="optionCode", default=None
     )
+
+
+class DhcpSeverCreationPayload(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    name: str
+    description: Optional[str] = None
+    data: DhcpServerData
+    metadata: Optional[dict] = None

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

@@ -1,11 +1,12 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
 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.models.configuration.feature_profile.common import AddressWithMask, RefIdItem
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable
+from catalystwan.models.configuration.feature_profile.common import Prefix
 
 EigrpAuthType = Literal[
     "md5",
@@ -25,79 +26,81 @@ RedistributeProtocol = Literal[
 
 
 class KeychainDetails(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
-
-    key_id: Union[Global[int], Variable, Default[None]] = Field(
-        default=Default[None](value=None), serialization_alias="keyId", validation_alias="keyId"
-    )
-    keystring: Union[Global[str], Variable, Default[None]] = Field(default=Default[None](value=None))
+    key_id: Union[Global[int], Variable, Default[None]] = Field(serialization_alias="keyId", validation_alias="keyId")
+    keystring: Union[Global[str], Variable, Default[None]]
 
 
 class EigrpAuthentication(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: Union[Global[EigrpAuthType], Variable, Default[None]] = Default[None](value=None)
+    auth_type: Union[Global[EigrpAuthType], Variable, Default[None]] = Field(
+        serialization_alias="type", validation_alias="type"
+    )
     auth_key: Optional[Union[Global[str], Variable, Default[None]]] = Field(
-        serialization_alias="authKey", validation_alias="authKey", default=Default[None](value=None)
+        serialization_alias="authKey", validation_alias="authKey"
     )
-    key: Optional[List[KeychainDetails]] = None
+    key: Optional[List[KeychainDetails]] = Field(serialization_alias="key", validation_alias="key")
 
 
 class TableMap(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)
 
-    name: Optional[Union[Default[None], RefIdItem]] = Default[None](value=None)
+    name: Optional[Union[Default[None], Global[UUID]]] = Default[None](value=None)
     filter: Optional[Union[Global[bool], Variable, Default[bool]]] = Default[bool](value=False)
 
 
 class SummaryAddress(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)
 
-    prefix: AddressWithMask
+    prefix: Prefix
 
 
 class IPv4StaticRoute(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)
 
     name: Union[Global[str], Variable]
-    shutdown: Optional[Union[Global[bool], Variable, Default[bool]]] = Default[bool](value=False)
-    summary_address: List[SummaryAddress] = Field(
-        serialization_alias="summaryAddress", validation_alias="summaryAddress", default_factory=list
+    shutdown: Optional[Union[Global[int], Variable, Default[bool]]] = Default[bool](value=False)
+    summary_address: Optional[List[SummaryAddress]] = Field(
+        serialization_alias="summaryAddress", validation_alias="summaryAddress"
     )
 
 
 class RedistributeIntoEigrp(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)
 
     protocol: Union[Global[RedistributeProtocol], Variable]
-    route_policy: Optional[Union[Default[None], RefIdItem]] = Field(
-        default=Default[None](value=None), serialization_alias="routePolicy", validation_alias="routePolicy"
-    )
+    route_policy: Optional[Union[Default[None], Global[UUID]]] = Default[None](value=None)
 
 
 class AddressFamily(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)
 
     redistribute: Optional[List[RedistributeIntoEigrp]] = None
-    network: List[SummaryAddress] = Field(min_length=1)
+    network: List[SummaryAddress]
 
 
-class EigrpParcel(_ParcelBase):
-    type_: Literal["routing/eigrp"] = Field(default="routing/eigrp", exclude=True)
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True, extra="forbid")
+class EigrpData(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    as_number: Union[Global[int], Variable] = Field(validation_alias=AliasPath("data", "asNum"))
-    address_family: AddressFamily = Field(validation_alias=AliasPath("data", "addressFamily"))
+    as_number: Union[Global[int], Variable] = Field(serialization_alias="asNum", validation_alias="asNum")
+    address_family: AddressFamily = Field(serialization_alias="addressFamily", validation_alias="addressFamily")
     hello_interval: Union[Global[int], Variable, Default[int]] = Field(
-        validation_alias=AliasPath("data", "helloInterval"), default=Default[int](value=5)
+        serialization_alias="helloInterval", validation_alias="helloInterval", default=Default[int](value=5)
     )
     hold_time: Union[Global[int], Variable, Default[int]] = Field(
-        validation_alias=AliasPath("data", "holdTime"), default=Default[int](value=15)
-    )
-    authentication: Optional[EigrpAuthentication] = Field(
-        validation_alias=AliasPath("data", "authentication"), default=None
+        serialization_alias="holdTime", validation_alias="holdTime", default=Default[int](value=15)
     )
+    authentication: Optional[EigrpAuthentication] = None
     af_interface: Optional[List[IPv4StaticRoute]] = Field(
-        validation_alias=AliasPath("data", "afInterface"), default=None
+        serialization_alias="afInterface", validation_alias="afInterface", default=None
     )
-    table_map: TableMap = Field(validation_alias=AliasPath("data", "tableMap"), default=TableMap())
+    table_map: TableMap = Field(serialization_alias="tableMap", validation_alias="tableMap", default=TableMap())
+
+
+class EigrpCreationPayload(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    name: str
+    description: Optional[str] = None
+    data: EigrpData
+    metadata: Optional[dict] = None

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

@@ -1,17 +1,81 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from ipaddress import IPv6Address, IPv6Interface
-from typing import Optional, Union
+from typing import Literal, Optional, Union
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from catalystwan.api.configuration_groups.parcel import Default, Global, Variable
-from catalystwan.models.common import VrrpTrackerAction
+
+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]
 
 
 class VrrpTrackingObject(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)
 
     tracker_id: Union[Default[None], Global[UUID]] = Field(
         serialization_alias="trackerId", validation_alias="trackerId"
@@ -25,9 +89,26 @@ class VrrpTrackingObject(BaseModel):
 
 
 class VrrpIPv6Address(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)
 
-    ipv6_link_local: Union[Global[str], Global[IPv6Address], Variable] = Field(
+    ipv6_link_local: Union[Global[str], Variable] = Field(
         serialization_alias="ipv6LinkLocal", validation_alias="ipv6LinkLocal"
     )
-    prefix: Optional[Union[Global[str], Global[IPv6Interface], Variable, Default[None]]] = None
+    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]